(FILECREATED " 3-MAY-74 15:52:06" PUP5
changes to: FINAL:PREADLIST, OLD:PREADLIST, DETERMINE:ARG2:VALUE, DETERMINE:ARG3:VALUE, DETERMINE:ARG:VALUE,
INSERT:PRINT:STATEMENTS, PUP5FNS, PUP5VARS, ASSERT:LISTS, EXPERTAG, PREADLIST, PROPERTY:LIST:SETUP
previous date: "257:38 *** FINIS")
(DEFINEQ
(@
(LAMBDA (C)
C))
(A:BEING:ORDER
(LAMBDA (B1 B2)
(LESSP (FAST:BEING:COMPLEX B1)
(FAST:BEING:COMPLEX B2))))
(A:BEING:WHEN
(LAMBDA (BB)
(SETQ SUM 0)
(MAPC (GETP BB WHEN)
(FUNCTION (LAMBDA (W)
(COND
((EVAL (CAR W))
(SETQ SUM (PLUS SUM (EVAL (CADR W)))))))))
SUM))
(AD
(LAMBDA (L RP5)
(MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y))))
(SETQ PUP5FNS (SORT (APPEND PUP5FNS L)))
(SETQ PUP5FNS (INTERSECTION PUP5FNS PUP5FNS))
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (X)
(REMPROP X SPEC:WHY))))
(SETQ SET:OF:BEINGS (SORT (APPEND SET:OF:BEINGS)))
(SETQ RP5 (REVERSE PUP5VARS))
(SETQ PUP5VARS (APPEND (SORT (APPEND (CDDDR RP5)))
(LIST (CADDR RP5)
(CADR RP5)
(CAR RP5))))
(MAKEFILE (QUOTE PUP5))))
(ADD:BEING
(LAMBDA (B TREAD)
(SET B B)
(PUT B BEING T)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (X)
(PUPRIN1 X)
(PUPRIN1 " ")
(COND
((SETQ TREAD (PREAD))
(PUT B X TREAD))))))
(PUPRIN1 "*** FINISHED ***
SHOULD I MAKE A NEW FILE OF PUP? (T OR NIL)..... ")
(SETQ SET:OF:BEINGS (CONS B SET:OF:BEINGS))
(SETQ IS:BEING:LIST (CONS B IS:BEING:LIST))
(SEMI:COMPILE B)
(ADD:EFFECTS B)
(ADD:IDEN B)
(COND
((MEMBER WRITE:PROGRAM PUP5FNS)
(COND
((PREAD)
(AD (LIST B)))
(T (SETQ PUP5FNS (CONS B PUP5FNS))
T)))
((PREAD)
(AD NIL))
((LENGTH PUP5FNS)))))
(ADD:EFFECTS
(LAMBDA (B)
(SETQ TEMPG (APPEND (GETP B MAIN:EFFECTS)))
(SETQ EFFECTS:TABLE (APPEND EFFECTS:TABLE TEMPG))
(SORT EFFECTS:TABLE CAAR:ORDER)))
(ADD:IDEN
(LAMBDA (B)
(SETQ TEMPG (APPEND (GETP B IDEN)))
(SETQ IDEN:TABLE (APPEND IDEN:TABLE TEMPG))
(SORT IDEN:TABLE CAAR:ORDER)))
(ASSERTIONS
(LAMBDA (TEMPA)
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA (L)
(SETQ TEMPA (CONS (LIST L (EVAL L))
TEMPA)))))
TEMPA))
(ATOMP
(LAMBDA (SOMETHING)
(ATOM SOMETHING)))
(ATTENTION:DEMONS
(LAMBDA NIL T))
(BREAK:PREADLIST
(LAMBDA (N)
(SETQ FINAL:PREADLIST (NTH OLD:PREADLIST N))
(SETQ OLD:PREADLIST (FIRSTN (SUB1 N)
OLD:PREADLIST))
(PUPRIN1 OLD:PREADLIST)
(PUPRIN1 " *** ")
(PUPRIN1 FINAL:PREADLIST)
(LENGTH FINAL:PREADLIST)))
(CAAR:ORDER
(LAMBDA (O1 O2)
(CAR:ORDER (CAR O1)
(CAR O2))))
(CAR:ORDER
(LAMBDA (O1 O2)
(COND
(O1 (COND
(O2 (COND
((EQUAL (CAR O1)
(CAR O2))
(CAR:ORDER (CDR O1)
(CDR O2)))
((ATOM (CAR O1))
(ALPHORDER (CAR O1)
(CAR O2)))
((ATOM (CAR O2))
NIL)
(T (CAR:ORDER (CAR O1)
(CAR O2)))))
(T NIL)))
(T T))))
(CHANGEB
(LAMBDA (B:NAME B:PART)
(COND
((MEMBER B:NAME IS:BEING:LIST)
(SETQ STICKY:BNAME B:NAME))
(T (SETQ B:PART B:NAME)
(PUPRINT (SETQ B:NAME STICKY:BNAME))))
(COND
((MEMBER B:PART SET:OF:BEING:PARTS)
(SETQ STICKY:BPART B:PART))
(B:PART (PUPRIN1 "
I ASSUME YOU MADE AN ERROR
")
(ERROR!))
(T (PUPRINT (SETQ B:PART STICKY:BPART))))
(SETQ TEMP (GETP B:NAME B:PART))
(EDITV TEMP)
(COND
((EQUAL B:PART MAIN:EFFECTS)
(REMOVE:EFFECTS B:NAME))
((EQUAL B:PART IDEN)
(REMOVE:IDEN B:NAME)))
(PUT B:NAME B:PART TEMP)
(COND
((MEMBER B:PART COMPILABLE:BEING:PARTS)
(SEMI:COMPILE B:NAME)))
(COND
((NULL TEMP)
(REMPROP B:NAME B:PART))
((EQUAL B:PART MAIN:EFFECTS)
(ADD:EFFECTS B:NAME))
((EQUAL B:PART IDEN)
(ADD:IDEN B:NAME)))
T))
(CHANGEP
(LAMBDA (P)
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(SETQ X (GETP B P))
(PUPRINT B)
(COND
((ATOM X)
(PUPRIN1 "SORRY, PART IS NIL. NEW PART ....... ")
(SETQ X (PREAD)))
(T (EDITV X)))
(PUT B P X))))))
(CLASS
(NLAMBDA FORM
(MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1))))))))
(COLON:BACK
(LAMBDA (LL MM)
(SETQ MM (CAR LL))
(SETQ LL (MAPCAR (CDR LL)
(FUNCTION (LAMBDA (E)
(CONCAT ":" E)))))
(SETQ LL (CONS MM LL))
(PACK LL)))
(COLON:BREAK
(LAMBDA (E)
(PROG (UP RP BUFF)
(SETQ UP (UNPACK E))
(SETQ BUFF NIL)
LL (COND
((NULL UP)
(SETQ RP (CONS (PACK BUFF)
RP))
(RETURN (REVERSE RP))))
(COND
((MEMBER (CAR UP)
BREAKUP:LIST)
(SETQ RP (CONS (PACK BUFF)
RP))
(SETQ BUFF NIL))
(T (SETQ BUFF (NCONC1 BUFF (CAR UP)))))
(SETQ UP (CDR UP))
(GO LL))))
(COMMENT
(NLAMBDA FORM
(CONS COMMENT (MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1)))))))))
(COMPATIBLE
(LAMBDA (A B)
T))
(CSORT
(NLAMBDA X
(MAPC X (FUNCTION (LAMBDA (L)
(SET L (SORT (APPEND (EVAL L)))))))))
(DEFERRAL:DEMON
(LAMBDA NIL
(MAPCAR UNDEFERRED:DECISION:LIST DEFER:DECISION)
T))
(DETERMINE:ARG2:VALUE
(LAMBDA (CHOICE1 ENT2 HOLD:ANY2)
(SETQ ARG2 UNKNOWN)
(SETQ ENT2 (CADDR (SASSOC (CADR CHOICE1)
TRUE:FN:CALL:LIST)))
(COND
((NULL ENT2)
(SOME TRUE:FN:CALL:LIST (FUNCTION (LAMBDA (TF)
(COND
((MATCH (TUPLE FRAG1 ANY2 ANY1 (CADR CHOICE1))
TF)
(SETQ ENT2 (PACK (LIST (QUOTE AN:ELEMENT:OF:)
ANY1))))))))))
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND
((MATCH (VECTOR ANY2 TYPE OF (LIST VECTOR ENT2)
IS ANY2 AND IS USED IN (CADR CHOICE1))
TOL)
(SETQ ARG2 ANY2))))))
(COND
((EQUAL ARG2 UNKNOWN)
(SETQ ARG2 ENT2)))
(COND
((MATCH (TUPLE A R G ANY2)
(UNPACK ARG2))
(SETQ HOLD:ANY2 UNKNOWN)
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL2)
(COND
((MATCH (VECTOR (CADR CHOICE1)
TYPE OF FRAG2 USED IN ANY2)
TOL2)
(SETQ HOLD:ANY2 ANY2))))))
(COND
((EQUAL UNKNOWN HOLD:ANY2)
ARG2)
((EQUAL ARG2 (QUOTE ARG1))
(DETERMINE:ARG:VALUE (LIST VECTOR HOLD:ANY2)))
(T (DETERMINE:ARG2:VALUE (LIST VECTOR HOLD:ANY2)))))
(ARG2))))
(DETERMINE:ARG3:VALUE
(LAMBDA (CHOICE1 ENT2 HOLD:ANY2)
(SETQ ARG3 UNKNOWN)
(SETQ ENT2 (CADDDR (SASSOC (CADR CHOICE1)
TRUE:FN:CALL:LIST)))
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND
((MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR ENT2)
IS ANY2 AND IS USED IN (CADR CHOICE1))
TOL)
(SETQ ARG3 ANY1))))))
(COND
((EQUAL ARG3 UNKNOWN)
(SETQ ARG3 ENT2)))
(COND
((MATCH (TUPLE A R G ANY2)
(UNPACK ARG3))
(SETQ HOLD:ANY2 UNKNOWN)
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL2)
(COND
((MATCH (VECTOR (CADR CHOICE1)
TYPE OF FRAG2 USED IN ANY2)
TOL2)
(SETQ HOLD:ANY2 ANY2))))))
(COND
((EQUAL UNKNOWN HOLD:ANY2)
ARG3)
((EQUAL ARG3 (QUOTE ARG1))
(DETERMINE:ARG:VALUE (LIST VECTOR HOLD:ANY2)))
(T (DETERMINE:ARG2:VALUE (LIST VECTOR HOLD:ANY2)))))
(ARG3))))
(DETERMINE:ARG:VALUE
(LAMBDA (CHOICE1 ENT2 HOLD:ANY2)
(SETQ ARG1 UNKNOWN)
(SETQ ENT2 (CADR (SASSOC (CADR CHOICE1)
TRUE:FN:CALL:LIST)))
(COND
((NULL ENT2)
(SOME TRUE:FN:CALL:LIST (FUNCTION (LAMBDA (TF)
(COND
((MATCH (TUPLE FRAG1 ANY1 ANY2 (CADR CHOICE1))
TF)
(SETQ ENT2 ANY1))))))))
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND
((MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR ENT2)
IS ANY2 AND IS USED IN (CADR CHOICE1))
TOL)
(SETQ ARG1 ANY1))))))
(COND
((EQUAL ARG1 UNKNOWN)
(SETQ ARG1 ENT2)))
(COND
((MATCH (TUPLE A R G ANY2)
(UNPACK ARG1))
(SETQ HOLD:ANY2 UNKNOWN)
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA (TOL2)
(COND
((MATCH (VECTOR (CADR CHOICE1)
TYPE OF FRAG2 USED IN ANY2)
TOL2)
(SETQ HOLD:ANY2 ANY2))))))
(COND
((EQUAL UNKNOWN HOLD:ANY2)
ARG1)
((EQUAL ARG1 (QUOTE ARG1))
(DETERMINE:ARG:VALUE (LIST VECTOR HOLD:ANY2)))
(T (DETERMINE:ARG2:VALUE (LIST VECTOR HOLD:ANY2)))))
(ARG1))))
(DIMENSION1
(LAMBDA (B)
(EVAL (CAR (GETP B COMPLEXITY:VECTOR)))))
(DIMENSION2
(LAMBDA (B)
(EVAL (CADR (GETP B COMPLEXITY:VECTOR)))))
(DIMENSION3
(LAMBDA (B)
(EVAL (CADDR (GETP B COMPLEXITY:VECTOR)))))
(DISK:DUMP
(LAMBDA (FILE STUFF)
(SETQ FILEVARS (MKATOM (CONCAT (MKSTRING FILE)
"VARS")))
(SET FILEVARS (QUOTE (EVERYTHING)))
(SETQ EVERYTHING STUFF)
(MAKEFILE FILE)))
(DOT:PROD
(LAMBDA (L1 L2)
(COND
(L1 (PLUS (COND
(L2 (TIMES (CAR L1)
(CAR L2)))
(T 0.0))
(DOT:PROD (CDR L1)
(CDR L2))))
(T 0))))
(DUMMIES
(LAMBDA (NDUM)
(COND
((ZEROP NDUM)
NIL)
(T (CONS (COLON:BACK (LIST DUMMY:ARGUMENT NDUM))
(DUMMIES (SUB1 NDUM)))))))
(DUMP:BEING
(LAMBDA (B)
(PRIN1 "************************* ")
(PRINT B)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (X)
(COND
((SETQ X2 (GETP B X))
(PRINT X)
(COND
((ATOM X2)
(PRINT X2))
(T (PP X2)))
(TERPRI))))))
(QUOTE FINISHED)))
(ECONOMY:DEMON
(LAMBDA NIL
(SETQ AWARE:PUP:LIST NIL)
(SETQ PUP:SATISFIED:LIST NIL)))
(ENTER
(LAMBDA (EXPERTISE)
(SETQ NEW:F:NUMBER 0)
(SETQ NEW:P:NUMBER 0)
(SETQ RESULT:COUNTER 0)
(SETQ LABEL:COUNTER 0)
(MAPC (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (P)
(REMPROP B P))))
(REMPROP B BEING)
(SET B UNKNOWN))))
(MAPC TRIVIAL:BEING:LIST (FUNCTION (LAMBDA (TB)
(PUT TB BEING T)
(SET TB TB))))
(SETQ IS:BEING:LIST SET:OF:BEINGS)
(SET:UP:IDEN:TABLE)
(SET:UP:EFFECTS:TABLE)
(COND
((AND OLD:PREADLIST (PRIN1 "
I CAN GUESS ALL YOUR ANSWERS FOR A WHILE; SHOULD I? ")
(MEMBER (READ)
(TUPLE Y YES MAYBE)))
(SETQ PREADLIST OLD:PREADLIST))
(T (SETQ PREADLIST NIL)))
(START EXPERTISE)
(PUPRIN1 "
EXITING FROM THE SYSTEM.
")))
(FAD
(LAMBDA (L TEMP5)
(MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y))))
(SETQ PUP5FNS (SORT (COPY (APPEND PUP5FNS L IS:BEING:LIST))))
(SETQ PUP5FNS (INTERSECTION PUP5FNS PUP5FNS))
(SETQ TEMP5 PUP5VARS)
(SETQ PUP5VARS (REVERSE (CONS (QUOTE (P (PUPRIN1 " FULL PUP FILE; USE MAD OR AD OR MAKEFILE FOR NEW VERSION ")))
(APPEND (CDR (REVERSE PUP5VARS))
ASSERT:LISTS))))
(MAPC IS:BEING:LIST (FUNCTION (LAMBDA (X)
(PUT X SPEC:WHY (QUOTE (QUOTE (NO SPECIAL REASON)))))))
(MAKEFILE (QUOTE PUP5))
(SETQ PUP5VARS TEMP5)
(SETQ PUP5FNS (SETDIFFERENCE PUP5FNS IS:BEING:LIST))
T))
(FAST:BEING:COMPLEX
(LAMBDA (B)
(COND
((NOT (ATOM B))
(SETQ B (CAR B))))
(COND
((GETP B COMPLEXITY:VECTOR)
(DOT:PROD (QUOTE (.01 .06 .03 0.0 .9))
(MAPCAR (GETP B COMPLEXITY:VECTOR)
EVAL)))
(T 1.0))))
(FIND:AND:TAG
(LAMBDA (TARGET STUFF)
(COND
((NOT (LISTP STUFF))
(LIST STUFF))
((MEMBER (CAR STUFF)
(COMMENT QUOTE STRUCTURE))
(LIST STUFF))
((MATCH TARGET STUFF)
(SETQ NTAG2 T)
(LIST STUFF "***TAG***"))
((LIST (MAPCONC STUFF (FUNCTION (LAMBDA (STU)
(FIND:AND:TAG TARGET STU)))))))))
(FIRST:FEW
(LAMBDA (L N)
(SETQ N (PLUS 1 (IQUOTIENT (LENGTH L)
2)))
(REVERSE (NTH (REVERSE L)
N))))
(FIRSTN
(LAMBDA (N L)
(PROG (TTT)
LLL (COND
((ZEROP N)
(RETURN TTT)))
(SETQ N (SUB1 N))
(SETQ TTT (NCONC1 TTT (CAR L)))
(SETQ L (CDR L))
(GO LLL))))
(FLATTEN
(LAMBDA (L)
(COND
((NOT (LISTP L))
(LIST L))
(T (APPEND (FLATTEN (CAR L))
(FLATTEN (CDR L)))))))
(FLOW:PRECEDED
(LAMBDA (FORM)
(PUPRIN1 "
FLOW:PRECEDED ISNT IN YET.
")
(PUPRIN1 "LOOK AT ARGUMENT AND ANSWER T OR NIL:
")
(PUPRINT FORM)
(PUPRIN1 "
(THIS WOULD NORMALLY BE DONE BY SYSTEM, NOT BY USER .... ")
(PREAD)))
(FOREVER
(LAMBDA NIL NIL))
(FORGETFUL:USER:DEMON
(LAMBDA NIL
(SETQ AWARE:USER:LIST (SETUNION FRINGE:CONCIOUS:LIST (LIST (CAR AWARE:USER:LIST))))
T))
(FRINGE:OF:CONCIOUSNESS:DEMON
(LAMBDA NIL T))
(GETCODE
(LAMBDA (F1 FNAME LEVEL C1 C2 OLDNAME:TAG C11 F1BACKUP)
(COND
((NOT (LISTP F1))
(COND
((MEMBER F1 ARG:LIST)
(SETQ FARGS (NCONC1 FARGS F1))
F1)
((MEMBER F1 PRIMITIVE:PROGRAMS:LIST)
F1)
((MEMBER F1 TRIVIAL:BEING:LIST)
F1)
((NOT (GETP F1 BEING))
(COND
((OR (NOT (MINUSP LEVEL))
(AND (MATCH (TUPLE A R G ANY1)
(UNPACK F1))))
(SETQ FARGS (NCONC1 FARGS F1))))
F1)
((MEMBER F1 (LIST ARG1 (SETQ PS1 (PACK (TUPLE POSSIBLE: (@ ARG1))))
(PACK (TUPLE SET:OF: (PLURAL PS1)))))
F1)
((MEMBER F1 (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS))
F1)
((MEMBER F1 IS:STRUCTURE:LIST)
F1)
(T (SETQ F1BACKUP F1)
(GET:NAME (LIST VECTOR F1)
(VECTOR CNAME))
(COND
((NULL OLDNAME:TAG)
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ CNAME)
TYPE OF (LIST VECTOR F1BACKUP)
IS UNKNOWN BUT USED IN (@ FNAME))
TYPE:OF:LIST))
(SETQ UNDEFINED:SECTION:LIST (SETUNION UNDEFINED:SECTION:LIST (LIST (VECTOR (@ CNAME)
TYPE OF (LIST VECTOR
F1BACKUP)))))
)
(T (SETQ OLDNAME:TAG NIL)))
CNAME)))
((EVAL (GETP (CAR F1)
FORM:CHANGING)))
((MEMBER (CAR F1)
(QUOTE (COMMENT QUOTE NLAMBDA * STRUCTURE)))
F1)
((MATCH (TUPLE SETQ ANY1 ANY2)
F1)
(SETQ C1 ANY2)
(SETQ C11 ANY1)
(COND
((OR (NUMBERP (CAR (LAST (COLON:BREAK C11))))
(MATCH (TUPLE A R G FRAG1)
(UNPACK C11))
(MEMBER C11 ARG:LIST)
(MEMBER C11 (LIST ARG1 (SETQ PS1 (PACK (TUPLE POSSIBLE: (@ ARG1))))
(PACK (TUPLE SET:OF: (PLURAL PS1)))))
(MEMBER C11 PRIMITIVE:PROGRAMS:LIST)
(MATCH (TUPLE E V A L : A R G FRAG1)
(UNPACK C11)))
(SETQ CNAME C11))
(T (GET:NAME (LIST VECTOR C11)
(VECTOR CNAME))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ CNAME)
TYPE OF (LIST VECTOR C11)
IS USED IN (VECTOR ASSIGNMENT STATEMENT IN (@ FNAME)))
TYPE:OF:LIST))
(TUPLE SETQ (@ CNAME)
(GETCODE C1 FNAME (SUB1 LEVEL))))
(T (CONS (PROG1 (SETQ C1 (GETCODE (CAR F1)
FNAME
(SUB1 LEVEL)))
(COND
((AND (ATOM C1)
(NUMBERP (CAR (LAST (COLON:BREAK C1)))))
(SETQ FN:CALL:LIST (CONS (INVECTOR (CONS C1 (CDR F1)))
FN:CALL:LIST))))
(COND
((AND OLDNAME:TAG (SETQ VTCODE (GETP C1 META:CODE))
(EQUAL (CAR VTCODE)
(QUOTE PROGN)))
(PUT C1 META:CODE (APPEND (TUPLE PROGN (COMMENT IN SOME CALLS, ARG1 WAS INSTANTIATED AS
(CADR F1)))
(CDR VTCODE))))))
(PROG1 (SETQ C2 (GETCODE (CDR F1)
(COND
((MEMBER C1 PRIMITIVE:PROGRAMS:LIST)
FNAME)
((GETP C1 BEING)
C1)
(T FNAME))
(SUB1 LEVEL)))
(COND
((AND (ATOM C1)
(NUMBERP (CAR (LAST (COLON:BREAK C1)))))
(SETQ TRUE:FN:CALL:LIST (CONS (OUTVECTOR (CONS C1 C2))
TRUE:FN:CALL:LIST))))))))))
(HIGHLY:STRUCTURED
(LAMBDA (B)
(EQUAL (CAR (GETP B META:CODE))
STRUCTURE)))
(IDIOM:DEMON
(LAMBDA NIL T))
(IMPROBABILITY:COMPLEX
(LAMBDA (L)
(COND
((NUMBERP (CAR L)))
(650))))
(INCOMMENT
(LAMBDA (L)
(COND
((ATOM L)
L)
((EQUAL (CAR L)
COMMENT)
(MAPCAR L INCOMMENT))
(T (CONS COMMENT (MAPCAR L INCOMMENT))))))
(INFER:INSIDE
(LAMBDA (SUBROUTINE FN:NAME)
T))
(INFERENCE:DEMONS
(LAMBDA NIL T))
(INITIALS
(LAMBDA (L)
(MAPCAR L (FUNCTION (LAMBDA (E)
(CAR (UNPACK E)))))))
(INSERT:PRINT:STATEMENTS
(LAMBDA NIL
(PUPRIN1 " SORRY, I AM INSERTING THE PRINT STATMENTS BY OMNISCIENCE ")
(PUT PAD:2 META:CODE (SUBST (QUOTE (AND (FOREACH (QUOTE NAME)
IN SET:OF:POSSIBLE:NAMES:OF:CLASS DO
(QUOTE (PROGN (PUPRINT NAME)
(COND
((GETP NAME CLASS:OBJECTS:33)
(PUPRIN1 "OBJECTS ")
(PUPRINT (GETP NAME CLASS:OBJECTS:33))))
(COND
((GETP NAME CLASS:YES:RELNS:35)
(PUPRIN1 "MUST HAVE ")
(PUPRINT (GETP NAME CLASS:YES:RELNS:35))))
(COND
((GETP NAME CLASS:NO:RELNS:36)
(PUPRIN1 "MUSNT HAVE ")
(PUPRINT (GETP NAME CLASS:NO:RELNS:36))))
(COND
((GETP NAME CLASS:MAYBE:RELNS:37)
(PUPRIN1 "MAY HAVE ")
(PUPRINT (GETP NAME CLASS:MAYBE:RELNS:37))))
(TERPRI)
T)))
(GO LABEL:1)))
(QUOTE (GO LABEL:1))
(COPY (GETP PAD:2 META:CODE))))))
(INSTANTIATE
(LAMBDA (FORM)
(COND
((ATOM FORM)
FORM)
((EQUAL (CAR FORM)
$)
(EVAL (CADR FORM)))
(T (CONS (INSTANTIATE (CAR FORM))
(INSTANTIATE (CDR FORM)))))))
(INTUPLE
(LAMBDA (L)
(COND
((ATOM L)
L)
((EQUAL (CAR L)
TUPLE)
(MAPCAR L INTUPLE))
(T (CONS TUPLE (MAPCAR L INTUPLE))))))
(INVECTOR
(LAMBDA (L)
(COND
((ATOM L)
L)
((EQUAL (CAR L)
VECTOR)
(MAPCAR L INVECTOR))
(T (CONS VECTOR (MAPCAR L INVECTOR))))))
(IRRELEVANT
(LAMBDA (L)
(NOT (EVAL (CDR L)))))
(JPL
(LAMBDA NIL
(SETQ OLD:PREADLIST (APPEND OLD:PREADLIST FINAL:PREADLIST))))
(LEARN:BY:EXAMPLE
(LAMBDA (ARGVECTOR)
(PUPRIN1 "
LEARN BY EXAMPLE IS NOT IN YET; PLEASE TYPE IN WHAT IT SHOULD RETURN.
ITS ARGUMENT VECTOR IS ")
(PUPRIN1 ARGVECTOR)
(PUPRIN1 " . OK, TYPE IN ANSWER:
USER: ")
(INVECTOR (PREAD))))
(LIST:JOIN
(LAMBDA (LL FL)
(COND
(LL (LIST:JOIN (CDR LL)
(COND
((ATOM (CAR LL))
(NCONC1 FL (CAR LL)))
((LISTP (CAR LL))
(APPEND FL (CAR LL)))
(T FL))))
(T FL))))
(LIST:TRANSLATE
(LAMBDA (A B)
(COND
((LISTP A)
(TRANSLATE A B))
(T A))))
(LOCATION:TRANSLATE
(LAMBDA (LLL P1 P2 P3 VERB)
(SETQ P3 (CAR (SETINTERSECTION (TUPLE BEFORE AFTER)
LLL)))
(SETQ LLL (PULLOUT P3 LLL))
(SETQ VERB (UNGERUNDIFY (CAR LLL)))
(MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND
((AND (MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR VERB)
IS FRAG1 USED IN ANY2)
TOL)
(COMPATIBLE (CDR (SETQ P1 (SASSOC ANY1 TRUE:FN:CALL:LIST)))
(CDR LLL)))
(SETQ P2 (CAR (OUTVECTOR ANY2))))))))
(LIST P1 P2 P3)))
(LONG:NAME:DEMON
(LAMBDA (MLIST UPT LNAME)
(SETQ MLIST (MAPCONC (FLATTEN CODING:WARNING:LIST)
(FUNCTION (LAMBDA (SS)
(COND
((GREATERP (LENGTH (SETQ UPT (UNPACK SS)))
50)
(LIST SS)))))))
(MAPC (INTERSECTION MLIST MLIST)
(FUNCTION (LAMBDA (TOL)
(SETQQ LNAME LNAME)
(GET:NAME (VECTOR (COLON:BACK (REVERSE (CDR (REVERSE (COLON:BREAK TOL))))))
(VECTOR LNAME))
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA (AL)
(SET AL (DSUBST LNAME TOL (EVAL AL))))))
(MAPC (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B)
(COND
((GETP B META:CODE)
(PUT B META:CODE (DSUBST LNAME TOL (GETP B META:CODE)))))))))))))
(LUMP:ASSERTIONS
(LAMBDA (L TEMPL TEMPL2)
(SETQ TEMPL NIL)
(SETQ L (ASSERTIONS))
(MAPC L (FUNCTION (LAMBDA (L1)
(SETQ TEMPL (APPEND TEMPL (CADR L1))))))
(SETQ TEMPL2 (COPY TEMPL))
(SETQ TEMPL2 (INTERSECTION TEMPL2 TEMPL2))
(SORT TEMPL2)))
(MAD
(LAMBDA (L TEMP5)
(MAPC L (FUNCTION (LAMBDA (Y)
(SET Y Y))))
(SETQ PUP5FNS (SORT (APPEND PUP5FNS L)))
(SETQ PUP5FNS (INTERSECTION PUP5FNS PUP5FNS))
(SETQ PUP5FNS (SETDIFFERENCE PUP5FNS SET:OF:BEINGS))
(SETQ TEMP5 PUP5VARS)
(SETQ PUP5VARS (REVERSE (CONS (QUOTE (P (MAPC SET:OF:BEINGS SEMI:COMPILE)
(PUPRIN1 " MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION ")))
(CDR (REVERSE PUP5VARS)))))
(SETQ PUP5VARS (SETDIFFERENCE PUP5VARS ASSERT:LISTS))
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (X)
(PUT X SPEC:WHY (QUOTE (QUOTE (NO SPECIAL REASON)))))))
(MAKEFILE (QUOTE PUP5))
(SETQ PUP5VARS TEMP5)
(SETQ PUP5FNS (APPEND SET:OF:BEINGS PUP5FNS))
T))
(MAIN:WORDS
(LAMBDA (L)
(SETDIFFERENCE L MINOR:WORDS)))
(MAKE:SPECIFIC
(LAMBDA (A)
(SETQ IS:SPECIFIC:LIST (CONS A IS:SPECIFIC:LIST))))
(MATCH
(LAMBDA (A B LD)
(SETQ LD (ADD1 (DIFFERENCE (LENGTH B)
(LENGTH A))))
(SETQ MATCH:RESULT T)
(COND
((MINUSP LD)
(SETQ MATCH:RESULT NIL))
(T (MAPC A (FUNCTION (LAMBDA (A1)
(COND
((MEMB A1 (QUOTE (ANY1 ANY2 ANY3)))
(SET A1 (CAR B))
(SETQ B (CDR B)))
((MEMB A1 (QUOTE (FRAG1 FRAG2)))
(SET A1 (FIRSTN LD B))
(SETQ B (NTH B (ADD1 LD))))
((EQUAL A1 (CAR B))
(SETQ B (CDR B)))
((LISTP A1)
(SETQ MATCH:RESULT (AND MATCH:RESULT (MATCH A1 (CAR B))))
(SETQ B (CDR B)))
(T (SETQ MATCH:RESULT NIL))))))))
(AND (NULL B)
MATCH:RESULT)))
(MINIMUM
(LAMBDA (L F MINV MIN TV ELE NEWNUM MINNUM LHOLD MN MNTEMP)
(SETQ MNTEMP 1)
(SETQ MN 1)
(SETQ LHOLD L)
(SETQ L (OUTVECTOR L))
(SETQ MIN (CAR L))
(SETQ MINV (APPLY* F (COND
((MATCH (TUPLE ANY1 TYPE OF ANY2)
MIN)
(SETQ MINNUM (CAR (LAST (COLON:BREAK ANY1))))
(CAR ANY2))
((MATCH (TUPLE ANY2)
MIN)
(SETQ MINNUM (CAR (LAST (COLON:BREAK ANY2))))
ANY2)
((SETQ MINNUM UNKNOWN)
(CADAR (CDDDDR MIN))))))
(MAPC (CDR L)
(FUNCTION (LAMBDA (ELE)
(SETQ MNTEMP (ADD1 MNTEMP))
(COND
((OR (LESSP (SETQ TV (APPLY* F (COND
((MATCH (TUPLE ANY1 TYPE OF ANY2)
ELE)
(SETQ NEWNUM (CAR (LAST (COLON:BREAK ANY1))))
(CAR ANY2))
((MATCH (TUPLE ANY2)
ELE)
(SETQ NEWNUM (CAR (LAST (COLON:BREAK ANY2))))
ANY2)
((SETQ NEWNUM UNKNOWN)
(CADAR (CDDDDR ELE))))))
MINV)
(AND (EQUAL TV MINV)
(OR (AND (NUMBERP NEWNUM)
(NOT (NUMBERP MINNUM)))
(AND (NUMBERP NEWNUM)
(NUMBERP MINNUM)
(LESSP NEWNUM MINNUM)))))
(SETQ MIN ELE)
(SETQ MN MNTEMP)
(SETQ MINNUM NEWNUM)
(SETQ MINV TV))))))
(CAR (NTH LHOLD MN))))
(MOST:GENERAL
(LAMBDA (L)
(CAR L)))
(MOVE:BEING
(LAMBDA (B:OLD B)
(SET B B)
(PUT B BEING T)
(SETQ IS:BEING:LIST (CONS B IS:BEING:LIST))
(SETQ SET:OF:BEINGS (CONS B SET:OF:BEINGS))
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (P)
(PUT B P (COPY (GETP B:OLD P))))))
(ADD:EFFECTS B)
(ADD:IDEN B)
(COND
((MEMBER ENCODE PUP5FNS)
(SETQ PUP5FNS (CONS B PUP5FNS))))
(SEMI:COMPILE B)))
(MULT:INTERSECTION
(LAMBDA (L)
(COND
((CDDR L)
(SETINTERSECTION (CAR L)
(MULT:INTERSECTION (CDR L))))
(T (SETINTERSECTION (CAR L)
(CADR L))))))
(NEW:IDEN
(LAMBDA NIL
(MAPC SET:OF:BEINGS (FUNCTION (LAMBDA (B)
(PUT B IDEN (LIST (LIST (QUOTE AND)
(LIST (QUOTE EQUAL)
(QUOTE (CAR LI))
B)
(LIST (QUOTE EQUAL)
(QUOTE (LENGTH (CDR LI)))
(LENGTH (GETP B EXPLICIT:ARGS))))
(LIST (QUOTE LIST)
B
(LIST TRANSLATE (QUOTE (CADR LI)))))))))))
(NEW:LEVEL
(LAMBDA (EXPERTISE)
(PROG (NEWL)
L2 (COND
(EXPERTISE (PUPRIN1 "USER INTERRUPT LEVEL... "))
(T
(PUPRIN1
"HELLO THERE. I AM READY TO START .
HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
4 DURING EACH PHASE OF WRITING A PROGRAM
6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
OK, NOW TYPE A DIGIT... ")))
L (SETQ NEWL (COND
((NUMBERP EXPERTISE))
((PREAD))))
(SETQ EXPERTISE NIL)
(SETQ PERMANENT:USER:INTERRUPT:DEMONS
(SELECTQ
NEWL
(0 (CLASS))
(2 (CLASS USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END))
(4 (CLASS USER:INTERRUPT:AT:PHASES))
(6 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING))
(8 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING USER:INTERRUPT:AT:ADAPTING))
(10 (CLASS PERMIT:USER:INTERRUPT))
(AND
(PUPRIN1
"
*** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
TRY AGAIN:
")
(GO L))))
(SETQ USER:INTERRUPT:DEMONS PERMANENT:USER:INTERRUPT:DEMONS))))
(NOT:YET:INITIALIZED
(LAMBDA (ARGU)
(PUPRIN1 "
NOT:YET:INITIALIZED ISNT IN YET. LOOK AT ARG AND ANSWER T OR NIL...
")
(PUPRINT ARGU)
(PREAD)))
(NULLIFY
(LAMBDA (L)
(SET (CAR L)
NIL)
(COND
((CDR L)
(NULLIFY (CDR L))))))
(NUMBER:SUBST
(LAMBDA (NEW OLD FORM)
(COND
(FORM (CONS (COND
((EQUAL (CAR FORM)
OLD)
NEW)
((NUMBERP (CAR FORM))
(SETQ NEW:F:NUMBER (ADD1 NEW:F:NUMBER)))
((CAR FORM)))
(NUMBER:SUBST NEW OLD (CDR FORM)))))))
(OPPOSITE
(LAMBDA (WORD)
(SELECTQ WORD
(RELEVANT (QUOTE IRRELEVANT))
(IRRELEVANT (QUOTE RELEVANT))
(STATIC (QUOTE DYNAMIC))
(DYNAMIC (QUOTE STATIC))
(LE (QUOTE GT))
(GT (QUOTE LE))
(LT (QUOTE GE))
(GE (QUOTE LT))
(HAPPY (QUOTE SAD))
(SAD (QUOTE HAPPY))
(QUOTE TEMPORARILY))))
(OUTFORM
(LAMBDA (X L)
(COND
((NOT (LISTP L))
(LIST L))
((MEMBER X L)
NIL)
(T (LIST (APPEND (OUTFORM X (CAR L))
(CAR (OUTFORM X (CDR L)))))))))
(OUTNIL
(LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
NIL)
(OUTNIL (CDR S)))
(T (CONS (OUTNIL (CAR S))
(OUTNIL (CDR S)))))))
(OUTQUOTE
(LAMBDA (S)
(COND
((ATOM S)
S)
((EQUAL (CAR S)
(QUOTE QUOTE))
(CONS TUPLE (OUTQUOTE (CADR S))))
(T (CONS (OUTQUOTE (CAR S))
(OUTQUOTE (CDR S)))))))
(OUTTUPLE
(LAMBDA (S)
(COND
((NOT (LISTP S))
S)
((EQUAL (CAR S)
TUPLE)
(OUTTUPLE (CDR S)))
(T (CONS (OUTTUPLE (CAR S))
(OUTTUPLE (CDR S)))))))
(OUTVECTOR
(LAMBDA (S)
(COND
((NOT (LISTP S))
S)
((EQUAL (CAR S)
VECTOR)
(OUTVECTOR (CDR S)))
(T (CONS (OUTVECTOR (CAR S))
(OUTVECTOR (CDR S)))))))
(PBT
(LAMBDA NIL
(MAPDL (FUNCTION (LAMBDA (X)
(COND
((OR (MEMBER X PUP5FNS)
(MEMBER X IS:BEING:LIST))
(PUPRIN1 X)
(PUPRIN1 " "))))))
"***TOP***"))
(PBTV
(LAMBDA NIL
(MAPDL (FUNCTION (LAMBDA (X)
(COND
((OR (MEMBER X PUP5FNS)
(MEMBER X IS:BEING:LIST))
(PUPRINT X)
(PUPRINT (VARIABLES MAPDLPOS))
(PUPRINT (STKARGS MAPDLPOS))
(TERPRI))))))))
(PERMIT:DETAILED:DECISION
(LAMBDA NIL
(TERPRI)
(PUPRIN1 "SHOULD I DISCUSS RAMIFICATIONS?")
(COND
((EQUAL (PREAD)
YES)
(PUPRIN1 "I ASK NOW BECAUSE")
(PUPRIN1 (CADDDR D))
(PUPRIN1 " HAS THE NON-NULL VALUE ")
(PUPRIN1 (EVAL (CADDDR D)))
(COND
((MEMBER WHY (CADR D))
(PUPRIN1 "THIS, IN TURN, IS")
(PUPRIN1 (CDADR (MEMBER WHY (CADR D))))
(TERPRI)))
(COND
((MEMBER COMMENT (CADR D))
(PUPRIN1 "
ANOTHER COMMENT ABOUT THIS IS:
")
(PUPRINT (EVAL (CADR (MEMBER COMMENT (CADR D)))))))
(PUPRINT (CONCAT "ALL THIS IS IN THE FUNCTION " CHOICE))
(SELECTQ
DTYPE
(BOOLEAN (PUPRIN1 " THE EFFECT OF
ANSWERING YES IS ")
(PUPRIN1 (COND
((APPEND (CADR (MEMBER YES:RESULTS (CADR D)))
(CADR (MEMBER BOTH:RESULTS (CADR D)))))
(T (CDDADR (MEMBER AFFECTS (CADR D))))))
(TERPRI)
(PUPRIN1 (COND
((APPEND (CADR (MEMBER NO:RESULTS (CADR D)))
(CADR (MEMBER BOTH:RESULTS (CADR D)))))
(T "THE EFFECT OF ANSWERING NO IS THUS NO:EFFECT"))))
(SOMEOF
(PUPRIN1
"
WE SHALL REPEATEDLY DO SOME OF THESE ACTIONS. YOUR REPLY TELLS ME
WHICH ONE(S) ARE ACTUALLY INVOLVED IN THIS FUNCTION. YOUR ANSWER
AFFECTS ")
(PUPRINT (CDADR (MEMBER AFFECTS (CADR D)))))
(PROGN (PUPRIN1 "
YOUR REPLY AFFECTS ")
(PUPRINT (CDADR (MEMBER AFFECTS (CADR D))))))))))
(PERMIT:USER:INTERRUPT
(LAMBDA NIL
(COND
(EXPERTISE (PUPRIN1 "INTERRUPT? "))
(T (PUPRIN1 "
DO YOU WISH TO INTERRUPT ME NOW, TO ASK ME ABOUT WHAT I'M DOING? ")))
(SELECTQ (PREAD)
(Y (PROCESS:USER:INTERRUPT))
(N T)
(PROGN (PUPRIN1 "
NO, NO. TYPE Y OR N ......... ")
(PERMIT:USER:INTERRUPT)))))
(PLURAL
(LAMBDA (OBJECT)
(COND
((MATCH (TUPLE FRAG1 ANY1 OF ANY2)
(COLON:BREAK OBJECT))
(COLON:BACK (APPEND FRAG1 (LIST (PACK (LIST ANY1 (QUOTE S)))
(QUOTE OF)
ANY2))))
(T (PACK (LIST OBJECT (QUOTE S)))))))
(POP:DEMONS
(LAMBDA NIL
(SETQ CURRENT:DEMONS (CAR DEMON:STACK))
(SETQ DEMON:STACK (CDR DEMON:STACK))
T))
(PREAD
(LAMBDA (T82)
(COND
(PREADLIST (SETQ T82 (CAR PREADLIST))
(SETQ PREADLIST (CDR PREADLIST))
(PUPRINT T82))
(T (READ)))))
(PREPL
(LAMBDA (B)
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (P)
(COND
((SETQ BP (GETP B P))
(PUT B P (SUBPAIR (TUPLE READ RATOM)
(TUPLE PREAD PREAD)
(COPY BP)
T)))))))))
(PREPL2
(LAMBDA (OB)
(SUBPAIR (TUPLE READ RATOM)
(TUPLE PREAD PREAD)
(COPY OB)
T)))
(PRET
(LAMBDA (FN VAL)
(RETFROM (STKPOS FN)
VAL)))
(PROCEDURE:INTERSECTION
(LAMBDA (P P1 YTEMP)
(SETQ P1 (CAAR P))
(COND
((MEMBER NIL (MAPCAR (CDR P)
(FUNCTION (LAMBDA (P2)
(EQUAL (CAR P2)
P1)))))
NIL)
((EQUAL P1 (QUOTE PROGN))
(SETQ YTEMP (MULT:INTERSECTION (MAPCAR P (QUOTE CDR))))
(COND
((LESSP (LENGTH YTEMP)
2)
(CAR YTEMP))
(T (CONS P1 YTEMP))))
((LESSP (LENGTH P)
2)
(CAR P))
(T NIL))))
(PROCEDURE:PULLOUT
(LAMBDA (PIECE BODY PPRESULT)
(SETQ PPRESULT (COND
((NULL PIECE)
BODY)
((EQUAL (CAR BODY)
(CAR PIECE))
(CONS (CAR BODY)
(SETDIFFERENCE (CDR BODY)
(CDR PIECE))))
(T (CONS (CAR BODY)
(SETDIFFERENCE BODY (LIST (CAR BODY)
PIECE))))))
(COND
((MATCH (TUPLE PROGN ANY1)
PPRESULT)
ANY1)
(T PPRESULT))))
(PROCEDURE:SUBSET
(LAMBDA (A1 A2)
(NOT (MEMBER NIL (MAPCAR (CDR A1)
(FUNCTION (LAMBDA (A3)
(MEMBER A3 A2))))))))
(PROCESS:USER:INTERRUPT
(LAMBDA NIL
(PROG (RESPONSE BC BC1 BC2)
(COND
((NOT EXPERTISE)
(PUPRINT (APPEND (QUOTE (BEING IS))
(LIST (CAR BEING:STACK))))
(PUPRIN1 " TYPE ? OR ")))
(SETQ BC (CAR BEING:STACK))
(SETQ BC1 NIL)
(SETQ BC2 (CDR BEING:STACK))
L (PUPRIN1 " REQUEST: ")
(SELECTQ
(SETQ RESPONSE (PREAD))
(CH (PUPRIN1 BC1)
(PUPRIN1 " *** ")
(PUPRIN1 BC)
(PUPRIN1 " *** ")
(PUPRIN1 BC2)
(TERPRI))
(?
(PUPRIN1
" YOUR OPTIONS ARE AS FOLLOWS:
QUIT END THE INTERRUPT
BEING PRINT NAME OF CURRENT BEING
DEMONS PRINT SET OF DEMONS CURRENTLY ACTIVE
CONTROL:HISTORY PRINT LIST OF BEINGS IN CONTROL, THE PATH FROM THE
CURRENT BEING BACK TO THE BEGINNING OF THE PROGRAM
OLDER CONSIDER THE BEING WHICH CALLED THE CURRENT ONE
YOUNGER CONSIDER THE BEING WHICH THE CURRENT ONE CALLED
OLDEST CONSIDER THE FIRST BEING IN CONTROL
YOUNGEST CONSIDER THE LAST BEING IN CONTROL
")
(PUPRIN1
"SPEC:WHEN AN EVALUATED VERSION OF 'WHEN'
FAIL END THE INTERRUPT AND CAUSE CURRENT BEING TO FAIL
")
(PUPRIN1 "NEW:LEVEL CHANGE THE USER:INTERRUPT LEVEL
")
(PUPRIN1
"SPEC:WHY PRINT OUT THE SPECIFIC REASON(S) THAT THIS BEING WAS
CALLED. THIS DIFFERS FROM 'WHY' IN SENSE THAT SPEC:WHY IS
THE REASON GIVEN BY THE CALLER, WHERAS WHY IS THE REASON
STORED WITH THE CURRENT BEING PERMANENTLY.
")
(MAPC SET:OF:BEING:PARTS (FUNCTION (LAMBDA (Y)
(PUPRIN1 Y)
(PUPRIN1 " PRINT OUT ")
(PUPRIN1 Y)
(PUPRIN1 " WITH RESPECT TO CURRENT BEING
")))))
(QUIT (COND
((NOT EXPERTISE)
(PUPRIN1 "
END OF INTERRUPT
")))
(RETURN T))
(FAIL (RETURN NIL))
(SPEC:WHEN (PUPRINT (MAPCAR (GETP BC WHEN)
(FUNCTION (LAMBDA (W)
(TUPLE (CAR W)
IS
(SETQ W2 (EVAL (CAR W)))
SO WE (COND
(W2 (QUOTE DO))
(T (QUOTE DONT)))
ADD IN THE WEIGHT (CADR W)
WHICH IN THE CURRENT CASE IS (EVAL (CADR W))
;THE EXPLANATION IS (EVAL (CADDR W)))))))
(PUPRINT (TUPLE THE FINAL WHEN VALUE IS THUS (A:BEING:WHEN BC))))
(BEING (PUPRINT BC))
(CONTROL:HISTORY (PUPRIN1 BC1)
(PUPRIN1 " *** ")
(PUPRIN1 BC)
(PUPRIN1 " *** ")
(PUPRIN1 BC2)
(TERPRI))
(DEMONS (PUPRIN1 CURRENT:DEMONS)
(PUPRIN1 "
THE DEMON STACK IS ")
(PUPRINT DEMON:STACK))
(OLDER (SETQ BC1 (NCONC1 BC1 BC))
(SETQ BC (CAR BC2))
(SETQ BC2 (CDR BC2))
(PUPRINT BC))
(NEW:LEVEL (NEW:LEVEL))
(YOUNGER (SETQ BC2 (CONS BC BC2))
(SETQ BC (LAST BC1))
(SETQ BC1 (REVERSE (CDR (REVERSE BC1))))
(PUPRINT BC))
(OLDEST (SETQ BC (LAST BEING:STACK))
(SETQ BC1 (REVERSE (CDR (REVERSE BEING:STACK))))
(SETQ BC2 NIL)
(PUPRINT BC))
(YOUNGEST (SETQ BC (CAR BEING:STACK))
(SETQ BC2 (CDR BEING:STACK))
(SETQ BC1 NIL)
(PUPRINT BC))
(COND
((MEMBER RESPONSE NON:EVAL:BEING:PARTS)
(PUPRINT (OUTVECTOR (OUTTUPLE (GETP BC RESPONSE)))))
((MEMBER RESPONSE EVAL:BEING:PARTS)
(PUPRINT (OUTVECTOR (EVAL (GETP BC RESPONSE)))))
((NLSETQ (PUPRINT (EVAL RESPONSE)))
T)
(T (PUPRIN1 "
*** ERROR *** TYPE ? FOR ASSISTANCE **********
")
(GO L))))
(GO L))))
(PROGRAM:WRITING:DEMONS
(LAMBDA NIL T))
(PSYCHOLOGY:DEMON
(LAMBDA NIL T))
(PULLOUT
(LAMBDA (E L)
(COND
((ATOM L)
L)
((EQUAL E (CAR L))
(CDR L))
(T (CONS (CAR L)
(PULLOUT E (CDR L)))))))
(PUPP
(LAMBDA (ST)
(SETQ NEW:P:NUMBER (ADD1 NEW:P:NUMBER))
(COND
(EXPERTAG (PRIN1 " ")
(PRIN1 NEW:P:NUMBER)
ST)
((APPLY* (QUOTE PP)
ST)))))
(PUPRETTYPRINT
(LAMBDA (ST)
(SETQ NEW:P:NUMBER (ADD1 NEW:P:NUMBER))
(COND
(EXPERTAG (PRIN1 " ")
(PRIN1 NEW:P:NUMBER)
ST)
((PRETTYPRINT ST)))))
(PUPRIN1
(LAMBDA (ST)
(SETQ NEW:P:NUMBER (ADD1 NEW:P:NUMBER))
(COND
(EXPERTAG (PRIN1 " ")
(PRIN1 NEW:P:NUMBER)
ST)
((PRIN1 ST)))))
(PUPRINT
(LAMBDA (ST)
(SETQ NEW:P:NUMBER (ADD1 NEW:P:NUMBER))
(COND
(EXPERTAG (PRIN1 " ")
(PRIN1 NEW:P:NUMBER)
ST)
((PRINT ST)))))
(PUSH:DEMONS
(LAMBDA (NEW:DEMONS NEW:DEMO)
(SETQ NEW:DEMO (SETDIFFERENCE NEW:DEMONS CURRENT:DEMONS))
(SETQ CURRENT:DEMONS (APPEND NEW:DEMO CURRENT:DEMONS))
(SETQ DEMON:STACK (CONS CURRENT:DEMONS DEMON:STACK))))
(REINVESTIGATION:DEMON
(LAMBDA NIL
(MAPCAR DEFERRED:DECISION:LIST (FUNCTION (LAMBDA (D)
(COND
((EVAL (CADDDR D))
(REINVESTIGATE:DECISION D))
(T NOT:TIME:YET)))))
T))
(RELEVANT
(LAMBDA (L)
(EVAL (CDR L))))
(REMOVE:EFFECTS
(LAMBDA (B)
(SETQ TEMPG (COPY (GETP B MAIN:EFFECTS)))
(MAPC TEMPG (FUNCTION (LAMBDA (E)
(SETQ EFFECTS:TABLE (PULLOUT E EFFECTS:TABLE)))))))
(REMOVE:IDEN
(LAMBDA (B)
(SETQ TEMPG (COPY (GETP B IDEN)))
(MAPC TEMPG (FUNCTION (LAMBDA (E)
(SETQ IDEN:TABLE (PULLOUT E IDEN:TABLE)))))))
(SELECT:STRUCTURE:TYPE
(LAMBDA (MCODE)
(COND
((AND (GREATERP (LENGTH MCODE)
3)
(NULL (SETINTERSECTION MCODE PART:INTERSECTION:LIST)))
(QUOTE PROPERTY:LIST))
(T (QUOTE LIST:VALUE)))))
(SEMI:COMPILE
(LAMBDA (B)
(EVAL (LIST (QUOTE DEFINEQ)
(LIST B (APPEND (TUPLE (COND
((GETP B NLAMBDA)
NLAMBDA)
(T (QUOTE LAMBDA))))
(LIST (APPEND (GETP B EXPLICIT:ARGS)
(GETP B IMPLICIT:ARGS)
(QUOTE (FN:VALUE FINAL:CO:REQ))))
(LIST (APPEND (LIST (QUOTE PROG1)
(APPEND (QUOTE (AND))
(LIST (LIST (QUOTE SETQ)
(QUOTE BEING:STACK)
(LIST (QUOTE CONS)
B
(QUOTE BEING:STACK))))
(COND
((GETP B DEMONS)
(LIST (LIST (QUOTE PUSH:DEMONS)
(GETP B DEMONS))))
(T NIL))
(COND
((NOT (EQUAL T (GETP B EXPLICIT:ARGS:CHECK)))
(LIST (GETP B EXPLICIT:ARGS:CHECK)))
(T NIL))
(MAPCAR (GETP B PRE:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY X))))
(GETP B COMMENTS)
(MAPCAR (GETP B CO:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST TRY:TO:SATISFY (LIST (QUOTE QUOTE)
X)))))
(LIST (LIST (QUOTE PUT)
B SPEC:WHY (QUOTE BECAUSE)))
(COND
((GETP B INHIBIT:CURRENT:DEMONS)
(QUOTE ((NOT (MEMBER NIL (MAPCAR USER:INTERRUPT:DEMONS
(QUOTE APPLY*)))))))
(T (QUOTE ((NOT (MEMBER NIL (MAPCAR (APPEND
CURRENT:DEMONS
USER:INTERRUPT:DEMONS)
(QUOTE APPLY*))))))))
(LIST (LIST (QUOTE SETQ)
(QUOTE FN:VALUE)
(GETP B META:CODE)))
(COND
((GETP B CO:REQUISITES)
(QUOTE ((NOT (MEMBER NIL (MAPCAR FINAL:CO:REQ SATISFY)))
)))
(T NIL))
(MAPCAR (GETP B POST:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST SATISFY X))))
(COND
((GETP B PREDICATE)
(QUOTE ((COND
(FN:VALUE)
(T FALSE)))))
(T (QUOTE (FN:VALUE)))))
(QUOTE (SETQ BEING:STACK (CDR BEING:STACK))))
(COND
((GETP B DEMONS)
(QUOTE ((POP:DEMONS))))
(T NIL))))))))))
(SET:UP:EFFECTS:TABLE
(LAMBDA (TEMPTOO E:TABLE)
(SETQ E:TABLE NIL)
(MAPC (COND
(TEMPTOO IS:BEING:LIST)
(T SET:OF:BEINGS))
(FUNCTION (LAMBDA (B)
(SETQ E:TABLE (APPEND E:TABLE (GETP B MAIN:EFFECTS))))))
(SETQ EFFECTS:TABLE (COPY E:TABLE))
(SORT EFFECTS:TABLE CAAR:ORDER)
(LENGTH EFFECTS:TABLE)))
(SET:UP:IDEN:TABLE
(LAMBDA (TEMPTOO E:TABLE)
(SETQ E:TABLE FUNDAMENTAL:IDEN:TABLE)
(MAPC (COND
(TEMPTOO IS:BEING:LIST)
(T SET:OF:BEINGS))
(FUNCTION (LAMBDA (B)
(SETQ E:TABLE (APPEND E:TABLE (GETP B IDEN))))))
(SETQ IDEN:TABLE (COPY E:TABLE))
(SORT IDEN:TABLE CAAR:ORDER)
(LENGTH IDEN:TABLE)))
(SETDIFFERENCE
(LAMBDA (S1 S2)
(COND
((NULL S1)
NIL)
(T (APPEND (COND
((MEMBER (CAR S1)
S2)
NIL)
(T (LIST (CAR S1))))
(SETDIFFERENCE (CDR S1)
S2))))))
(SETINTERSECTION
(LAMBDA (S1 S2)
(INTERSECTION S1 S2)))
(SETUNION
(LAMBDA (S1 S2)
(SETQ S1 (APPEND S1 S2))
(INTERSECTION S1 S1)))
(SINGLETON
(LAMBDA (S)
(NULL (CDR S))))
(SIZE
(LAMBDA (STRUC)
(ADD1 (IQUOTIENT (COUNT STRUC)
2))))
(SNAPSHOT
(LAMBDA (SLEVEL)
(SETQ SNAPFNS SLEVEL)
(MAKEFILE SNAP)))
(SPECIFICITY:CHECK:DEMON
(LAMBDA (ANYTHING)
(MAPC (SETDIFFERENCE PUP:WANTS:LIST IS:SPECIFIC:LIST)
MAKE:SPECIFIC)
T))
(START
(LAMBDA (EXPERTISE)
(PROG NIL
L1 (SETQ BEING:STACK NIL)
(SETQ BECAUSE (VECTOR))
(SETQ FORCE:TRANSLATE NIL)
(SETQ DEMON:STACK NIL)
(SETQ CURRENT:DEMONS NIL)
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA (L)
(SET L NIL))))
L2 (COND
(EXPERTISE (PUPRIN1 "USER INTERRUPT LEVEL... "))
(T
(PUPRIN1
"HELLO THERE. I AM READY TO START .
HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
4 DURING EACH PHASE OF WRITING A PROGRAM
6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
OK, NOW TYPE A DIGIT... ")))
(SETQ DOING:PUP:LIST (QUOTE ((COMMENT END OF STACK MARKER))))
L (SETQ PERMANENT:USER:INTERRUPT:DEMONS
(SELECTQ
(PREAD)
(0 (CLASS))
(2 (CLASS USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END))
(4 (CLASS USER:INTERRUPT:AT:PHASES))
(6 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING))
(8 (CLASS USER:INTERRUPT:AT:PHASES USER:INTERRUPT:AT:CODING USER:INTERRUPT:AT:ADAPTING))
(10 (CLASS PERMIT:USER:INTERRUPT))
(AND
(PUPRIN1
"
*** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
TRY AGAIN:
")
(GO L))))
(SETQ USER:INTERRUPT:DEMONS PERMANENT:USER:INTERRUPT:DEMONS)
(SETQ USER:INTERRUPT:COPY:OF:PHASES PROGRAM:WRITING:PHASES)
L3 (SERVE)
L4 (COND
(EXPERTISE
(PUPRIN1
"
FINISHED CURRENT SERVICE; WHAT SHOULD I DO? TYPE ONE OF:
1 EXIT FROM SYSTEM
2 CONTINUE SERVING, AS BEFORE
3 CONTINUE SERVING, BUT GET A NEW USER INTERRUPT LEVEL
4 REINITIALIZE SYSTEM AND START FROM BEGINNING AGAIN
OK, GO .......... "))
(T (PUPRIN1 "
FINISHED SERVICE. 1 EXIT; 2 CONTINUE; 3 NEW LEVEL; 4 START OVER ")))
(SELECTQ (PREAD)
(2 (GO L3))
(3 (GO L2))
(4 (GO L1))
(1 "EXITING SYSTEM")
(PUPRIN1 "NO, NO!!!!! ")
(GO L4)))))
(STRUCTURE
(NLAMBDA FORM
(CONS STRUCTURE FORM)))
(STRUCTURE:COMPATIBLE
(LAMBDA (B1 B2)
(COND
((AND (HIGHLY:STRUCTURED B1)
(HIGHLY:STRUCTURED B2)
(EQUAL (LENGTH (GETP B1 META:CODE))
(LENGTH (GETP B2 META:CODE))
(NOT (MEMBER NIL (MAP2CAR (GETP B1 META:CODE)
(GETP B2 META:CODE)
(FUNCTION (LAMBDA (P1 P2)
(EQUAL (CADR P1)
(CADR P2))))))))))
(T NIL))))
(STRUCTURE:INDUCING:DEMON
(LAMBDA (OBJECT PIECES)
(SETQ STAG NIL)
(COND
((GETP OBJECT BEING)
SORRY:NOT:IN:YET)
((AND (NULL (DETERMINE:ARG:VALUE CHOICE))
(NULL OBJECT))
(PUPRIN1
"
AT THIS POINT, I ALMOST RECOMMENDED VIRTUAL STRUCTURING, BUT DECIDED
AGAINST IT. THE LIST STRUCTURE WOULD HAVE BEEN DIVIDED INTO THESE
PIECES: ")
(PUPRINT PIECES)
(PUPRINT (TUPLE I GUESS THAT EACH OF THE ABOVE :NIL-S WOULD GET REPLACED BY SOMETHING LIKE
(CONCAT ":" (CAR (COLON:BREAK (CAR PIECES)))
(QUOTE :LIST))))
(TERPRI)
T)
((NULL OBJECT)
(TERPRI)
(PUPRINT (TUPLE IF SOME SORT OF (SETQ POSLIST (PACK (TUPLE KNOWN:LIST:OF: (PLURAL ARG1))))
EXISTED, THEN I WOULD RECOMMEND THAT IT BE STRUCTURED INTO (LENGTH PIECES)
PIECES, NAMED (@ PIECES)
,ALTHOUGH I GUESS THAT THE "NIL" -S SHOULD BE REPLACED BY (@ POSLIST)
-S. IF SUCH A LIST IS LATER CREATED, THIS COMMENT WILL STILL APPLY, BUT A GREAT DEAL OF CODE
MAY HAVE TO BE CHANGED.))
(TERPRI))
((PROGN (TERPRI)
(PUPRINT (TUPLE I RECOMMEND THAT (@ OBJECT)
BE STRUCTURED INTO (TUPLE AT LEAST ALONG ONE DIMENSION)
THESE
(LENGTH PIECES)
PIECES:
(@ PIECES)
.PLEASE TYPE BACK YES, NO, OR UNSURE.))
(PUPRIN1 "
USER: ")
(MEMBER (PREAD)
(QUOTE (Y YES T UNSURE MAYBE))))
(PROG (CODE BNAME)
(SETQ CODE (APPEND (STRUCTURE)
(MAPCAR PIECES (FUNCTION (LAMBDA (PIECE)
(TUPLE (@ PIECE)
SET OF (PLURAL ARG1)))))))
(SETQ BNAME LIST:STRUCTURE)
(SATISFY (VECTOR IS BEING OBJECT)))
(SETQ CODING:WARNING:LIST (CONS (TUPLE 10 VECTOR IN ALL CODE GENERATED, (@ OBJECT)
SHOULD BE REPLACED BY (CONS (QUOTE APPEND)
PIECES))
CODING:WARNING:LIST))
(LONG:NAME:DEMON)
(SETQ STAG T))
(T (PUPRIN1 "
OK, SO WE JUST GO ON NOW.
")))))
(SUBALLEVELS
(LAMBDA (NEW OLD FORM)
(COND
((CDR (COLON:BREAK OLD))
(SUBST NEW OLD FORM))
((NULL FORM)
NIL)
((LISTP FORM)
(CONS (SUBALLEVELS NEW OLD (CAR FORM))
(SUBALLEVELS NEW OLD (CDR FORM))))
((EQUAL FORM OLD)
NEW)
((ATOM FORM)
(COLON:BACK (SUBST NEW OLD (COLON:BREAK FORM))))
(FORM))))
(SUBSTITUTE
(LAMBDA (NEW FOR OLD IN LIST:STRUCTURE)
(SET LIST:STRUCTURE (SUBST NEW OLD (APPEND (EVAL LIST:STRUCTURE))))))
(TEMPORARILY
(LAMBDA (L)
(EVAL (CDR L))))
(TRACE:COMPILE
(LAMBDA (B)
(EVAL (LIST (QUOTE DEFINEQ)
(LIST B (APPEND (QUOTE (LAMBDA))
(LIST (APPEND (GETP B EXPLICIT:ARGS)
(GETP B IMPLICIT:ARGS)
(QUOTE (FN:VALUE FINAL:CO:REQ BEING:FLAG DEMON:FLAG))))
(LIST (LIST (QUOTE PROG1)
(APPEND (QUOTE (AND))
(LIST (LIST (QUOTE PUPRINT)
(LIST (QUOTE SETQ)
(QUOTE BEING:STACK)
(LIST (QUOTE CONS)
B
(QUOTE BEING:STACK)))))
(LIST (LIST (QUOTE PUPRINT)
(GETP B EXPLICIT:ARGS:CHECK)))
(MAPCAR (GETP B PRE:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PUPRINT)
(LIST SATISFY X)))))
(LIST (LIST (QUOTE PUPRINT)
(LIST (QUOTE PUSH:DEMONS)
(GETP B DEMONS))))
(MAPCAR (GETP B CO:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PUPRINT)
(LIST TRY:TO:SATISFY (LIST (QUOTE QUOTE)
X))))))
(QUOTE ((PUPRINT "COMMENTS BEGINNING")))
(GETP B COMMENTS)
(QUOTE ((PUPRINT "COMMENTS ENDING")))
(LIST (LIST (QUOTE PUPRINT)
(LIST (QUOTE PUT)
B SPEC:WHY (QUOTE BECAUSE))))
(QUOTE ((PUPRIN1 "NOT1 ")))
(QUOTE ((NOT (MEMBER NIL (PUPRINT (MAPCAR USER:INTERRUPT:DEMONS
(QUOTE APPLY*)))))))
(LIST (LIST (QUOTE PUPRINT)
(LIST (QUOTE SETQ)
(QUOTE FN:VALUE)
(GETP B META:CODE))))
(QUOTE ((PUPRIN1 "NOT2 ")))
(QUOTE ((NOT (MEMBER NIL (PUPRINT (MAPCAR FINAL:CO:REQ SATISFY))))))
(QUOTE ((PUPRINT (POP:DEMONS))))
(MAPCAR (GETP B POST:REQUISITES)
(FUNCTION (LAMBDA (X)
(LIST (QUOTE PUPRINT)
(LIST SATISFY X)))))
(QUOTE ((SETQ BEING:FLAG T)
(SETQ BEING:STACK (CDR (PUPRINT BEING:STACK)))))
(COND
((GETP B PREDICATE)
(QUOTE ((PUPRINT (COND
(FN:VALUE)
(T FALSE))))))
(T (QUOTE ((PUPRINT FN:VALUE))))))
(QUOTE (PUPRINT (TUPLE BEING:FLAG (@ BEING:FLAG)
DEMON:FLAG
(@ DEMON:FLAG))))
(QUOTE (PUPRINT (COND
((NULL BEING:FLAG)
(SETQ BEING:STACK (CDR BEING:STACK))
(POP:DEMONS))
(DEMON:FLAG (POP:DEMONS)))))))))))))
(TRUE:MINIMUM
(LAMBDA (L F MINV MIN TV ELE NEWNUM MINNUM LHOLD MN MNTEMP)
(SETQ MNTEMP 1)
(SETQ MN 1)
(SETQ LHOLD L)
(SETQ L (OUTVECTOR L))
(SETQ MIN (CAR L))
(SETQ MINV (APPLY* F MIN))
(MAPC (CDR L)
(FUNCTION (LAMBDA (ELE)
(SETQ MNTEMP (ADD1 MNTEMP))
(COND
((OR (LESSP (SETQ TV (APPLY* F ELE))
MINV)
(AND (EQUAL TV MINV)
(OR (AND (NUMBERP NEWNUM)
(NOT (NUMBERP MINNUM)))
(AND (NUMBERP NEWNUM)
(NUMBERP MINNUM)
(LESSP NEWNUM MINNUM)))))
(SETQ MIN ELE)
(SETQ MN MNTEMP)
(SETQ MINNUM NEWNUM)
(SETQ MINV TV))))))
(CAR (NTH LHOLD MN))))
(TRY:TO:SATISFY
(LAMBDA (SUBGOAL)
(COND
((SATISFY SUBGOAL)
T)
(T (SETQ FINAL:CO:REQ (CONS SUBGOAL FINAL:CO:REQ))))))
(TUPLE
(NLAMBDA FORM
(MAPCAR FORM (FUNCTION (LAMBDA (F2)
(COND
((ATOM F2)
F2)
(T (EVAL F2))))))))
(UNGERUNDIFY
(LAMBDA (W WLIST UFRAG RUFRAG)
(MATCH (TUPLE FRAG1 I N G)
(UNPACK W))
(SETQ UFRAG FRAG1)
(SETQ RUFRAG (REVERSE UFRAG))
(COND
((EQUAL (CAR RUFRAG)
(CADR RUFRAG))
(SETQ UFRAG (REVERSE (CDR RUFRAG)))))
(MAPC IS:BEING:LIST (FUNCTION (LAMBDA (B)
(COND
((MATCH (APPEND UFRAG (TUPLE FRAG1))
(UNPACK B))
(SETQ WLIST (CONS B WLIST)))))))
(COND
((LESSP (LENGTH WLIST)
2)
(CAR WLIST))
(T (SELECTQ (PACK UFRAG)
(GET (QUOTE GET:HOLD:OF))
(CAR WLIST))))))
(USER:INTERRUPT:AT:ADAPTING
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
ADAPT:PRECONCEIVED:FUNCTION)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:ADAPTING USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT)))))
(USER:INTERRUPT:AT:CODING
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
ENCODE)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:CODING USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT)))))
(USER:INTERRUPT:AT:DEBUG
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
CLARIFY:IMPROBABLE:SITUATION)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT)))))
(USER:INTERRUPT:AT:END
(LAMBDA (S:EXP)
(COND
((EQUAL (CAR BEING:STACK)
OPTIMIZE)
(SETQ USER:INTERRUPT:DEMONS (PULLOUT USER:INTERRUPT:AT:END USER:INTERRUPT:DEMONS))
(PERMIT:USER:INTERRUPT)))))
(USER:INTERRUPT:AT:PHASES
(LAMBDA (S:EXP)
(COND
((MEMBER (CAR BEING:STACK)
USER:INTERRUPT:COPY:OF:PHASES)
(SETQ USER:INTERRUPT:COPY:OF:PHASES (PULLOUT (CAR BEING:STACK)
USER:INTERRUPT:COPY:OF:PHASES))
(PERMIT:USER:INTERRUPT)))))
(VECTOR
(NLAMBDA FORM
(CONS VECTOR (MAPCAR FORM (FUNCTION (LAMBDA (F1)
(COND
((ATOM F1)
F1)
(T (EVAL F1)))))))))
(VECTOR:AVERAGE
(LAMBDA (L)
(LIST .8 .8 .8 .8 .1)))
(WHEN:VALUE
(LAMBDA (B:CALL EXP:A)
(SETQ EXP:A (GETP (CAR B:CALL)
EXPLICIT:ARGS))
(MAP2C EXP:A (CDR B:CALL)
(FUNCTION (LAMBDA (NEWARG OLDARG)
(SET NEWARG OLDARG))))
(COND
((EVAL (GETP (CAR B:CALL)
EXPLICIT:ARGS:CHECK))
(A:BEING:WHEN (CAR B:CALL)))
(T -1000))))
(Z@
(LAMBDA (X)
X))
)
(LISPXPRINT (QUOTE PUP5FNS)
T)
(RPAQQ PUP5FNS
(@ A:BEING:ORDER A:BEING:WHEN AD ADD:BEING ADD:EFFECTS ADD:IDEN ASSERTIONS ATOMP ATTENTION:DEMONS
BREAK:PREADLIST CAAR:ORDER CAR:ORDER CHANGEB CHANGEP CLASS COLON:BACK COLON:BREAK COMMENT COMPATIBLE CSORT
DEFERRAL:DEMON DETERMINE:ARG2:VALUE DETERMINE:ARG3:VALUE DETERMINE:ARG:VALUE DIMENSION1 DIMENSION2
DIMENSION3 DISK:DUMP DOT:PROD DUMMIES DUMP:BEING ECONOMY:DEMON ENTER FAD FAST:BEING:COMPLEX FIND:AND:TAG
FIRST:FEW FIRSTN FLATTEN FLOW:PRECEDED FOREVER FORGETFUL:USER:DEMON FRINGE:OF:CONCIOUSNESS:DEMON GETCODE
HIGHLY:STRUCTURED IDIOM:DEMON IMPROBABILITY:COMPLEX INCOMMENT INFER:INSIDE INFERENCE:DEMONS INITIALS
INSERT:PRINT:STATEMENTS INSTANTIATE INTUPLE INVECTOR IRRELEVANT JPL LEARN:BY:EXAMPLE LIST:JOIN
LIST:TRANSLATE LOCATION:TRANSLATE LONG:NAME:DEMON LUMP:ASSERTIONS MAD MAIN:WORDS MAKE:SPECIFIC MATCH
MINIMUM MOST:GENERAL MOVE:BEING MULT:INTERSECTION NEW:IDEN NEW:LEVEL NOT:YET:INITIALIZED NULLIFY
NUMBER:SUBST OPPOSITE OUTFORM OUTNIL OUTQUOTE OUTTUPLE OUTVECTOR PBT PBTV PERMIT:DETAILED:DECISION
PERMIT:USER:INTERRUPT PLURAL POP:DEMONS PREAD PREPL PREPL2 PRET PROCEDURE:INTERSECTION PROCEDURE:PULLOUT
PROCEDURE:SUBSET PROCESS:USER:INTERRUPT PROGRAM:WRITING:DEMONS PSYCHOLOGY:DEMON PULLOUT PUPP PUPRETTYPRINT
PUPRIN1 PUPRINT PUSH:DEMONS REINVESTIGATION:DEMON RELEVANT REMOVE:EFFECTS REMOVE:IDEN SELECT:STRUCTURE:TYPE
SEMI:COMPILE SET:UP:EFFECTS:TABLE SET:UP:IDEN:TABLE SETDIFFERENCE SETINTERSECTION SETUNION SINGLETON SIZE
SNAPSHOT SPECIFICITY:CHECK:DEMON START STRUCTURE STRUCTURE:COMPATIBLE STRUCTURE:INDUCING:DEMON SUBALLEVELS
SUBSTITUTE TEMPORARILY TRACE:COMPILE TRUE:MINIMUM TRY:TO:SATISFY TUPLE UNGERUNDIFY
USER:INTERRUPT:AT:ADAPTING USER:INTERRUPT:AT:CODING USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END
USER:INTERRUPT:AT:PHASES VECTOR VECTOR:AVERAGE WHEN:VALUE Z@))
(LISPXPRINT (QUOTE PUP5VARS)
T)
(RPAQQ PUP5VARS
($ ADAPTATION:DEFER:DECISION:KNOWLEDGE ADJECTIVES AFFECTS:ALL AFFECTS:ALL:DEFER:DECISION:KNOWLEDGE
ALTERNATIVES:DEFER:DECISION:KNOWLEDGE ALTERNATIVES:RESOLVE:DECISION:KNOWLEDGE
AND:LOOP:TERMINATION:KNOWLEDGE APPLIED:SO:AS:TO:KEEP ASSERT:LISTS BEING BOOLEAN:DEFER:DECISION:KNOWLEDGE
BOOLEAN:RESOLVE:DECISION:KNOWLEDGE BOTH:RESULTS BREAKUP:LIST CALL COMMENT COMPILABLE:BEING:PARTS
DEFINITION:DEFER:DECISION:KNOWLEDGE DEFINITION:RESOLVE:DECISION:KNOWLEDGE
DICHOTOMY:DEFER:DECISION:KNOWLEDGE DICHOTOMY:RESOLVE:DECISION:KNOWLEDGE DOES DOESNT DUMMY:ARGUMENT EQUAL
EQUALS EVAL EVAL:BEING:PARTS EXPERTAG FALSE FINAL:PREADLIST FLOW:ASSIGNMENT FOREVER FUNDAMENTAL:IDEN:TABLE
GLOBAL:CONTEXT:0 GO HOLD:GLOBALVARS INFERIOR ING IS IS:BEING:LIST ISNT KNOWLEDGE LABEL:COUNTER
LIST:VALUE:SETUP MASTER:PREADLIST MINOR:WORDS NAME NEW:P:NUMBER NO:RESULTS NON:EVAL:BEING:PARTS
NON:EXECUTABLE NOT:TIME:YET OLD:PREADLIST ONETYPE ONETYPE:DEFER:DECISION:KNOWLEDGE
ONETYPE:RESOLVE:DECISION:KNOWLEDGE PARTS PERMANENT:KNOWN:NAMES POSSIBLE PREADLIST
PREDICATE:DEFER:DECISION:KNOWLEDGE PREDICATE:RESOLVE:DECISION:KNOWLEDGE PRIMITIVE:PROGRAMS:LIST
PRIMITIVE:VARS:LIST PROGRAM:WRITING:PHASES PROPERTY:LIST:SETUP RESULT:COUNTER RESULTS SET:OF
SET:OF:BEING:PARTS SET:OF:BEINGS SINCE SNAP SNAPFNS SNAPVARS SOMEOF:DEFER:DECISION:KNOWLEDGE
SOMEOF:RESOLVE:DECISION:KNOWLEDGE STICKY:BNAME STICKY:BPART SUBSETOF:DEFER:DECISION:KNOWLEDGE
SUBSETOF:RESOLVE:DECISION:KNOWLEDGE SUPERIOR TRIVIAL:BEING:LIST UNKNOWN UNTIL WHEN:ALL
WHEN:ALL:DEFER:DECISION:KNOWLEDGE YES YES:RESULTS (COMS * (LIST (APPEND (QUOTE (PROP ALL))
SET:OF:BEINGS)))
(P (MAPC (APPEND PUP5FNS SET:OF:BEINGS SET:OF:BEING:PARTS ADJECTIVES)
(FUNCTION (LAMBDA (V)
(SET V V))))
(SETQ #RPARS NIL)
(DWIM)
(CHANGESLICE 6)
(SETQ GLOBALVARS HOLD:GLOBALVARS)
(SET:UP:IDEN:TABLE)
(SET:UP:EFFECTS:TABLE)
(WIDEPAPER T))
(P (MAPC SET:OF:BEINGS SEMI:COMPILE)
(PRIN1 " MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION "))))
(RPAQQ $ $)
(RPAQQ ADAPTATION:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ ADJECTIVES (STATIC DYNAMIC HARD SOFT EASY SIMPLE COMPLEX BIG LITTLE SMALL LARGE))
(RPAQQ AFFECTS:ALL AFFECTS:ALL)
(RPAQQ AFFECTS:ALL:DEFER:DECISION:KNOWLEDGE
(((VECTOR THE BASIC STRUCTURE OF FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF)
FRAG2)
DOING:PUP:LIST))
((VECTOR THE AMOUNT OF EFFORT ANY1 SHOULD SPEND ON FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF)
FRAG2)
DOING:PUP:LIST))
((VECTOR HOW ANY1 STORES FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF STORING)
FRAG2)
DOING:PUP:LIST))
((VECTOR THE ANY2 ALGORITHM)
(TUPLE MEMBER NIL (TUPLE MAPCAR DOING:PUP:LIST (TUPLE FUNCTION (TUPLE LAMBDA (QUOTE (PD))
(TUPLE NOT
(TUPLE MATCH
(VECTOR ANY1 TYPE OF
(LIST VECTOR
ANY2))
PD)))))))
((VECTOR CODE INVOLVING ANY1)
(TUPLE MEMBER NIL (TUPLE MAPCAR (TUPLE FLATTEN DOING:PUP:LIST)
(TUPLE FUNCTION
(TUPLE LAMBDA (QUOTE (PD))
(TUPLE NOT (TUPLE OR (TUPLE EQUAL (@ ANY1)
PD)
(TUPLE MEMBER (@ ANY1)
(TUPLE COLON:BREAK PD))
(TUPLE EQUAL (@ ANY1)
(TUPLE COLON:BACK
(TUPLE REVERSE
(TUPLE CDR
(TUPLE REVERSE
(TUPLE
COLON:BREAK PD))
)))))))))))
((VECTOR WHAT INFORMATION ANY1 MAY USE TO ANY2 FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF (PACK (LIST ANY2 ING)))
FRAG2)
DOING:PUP:LIST))
((VECTOR ANY1 DETAILS)
(TUPLE MEMBER (VECTOR DETAIL OF (PACK (LIST ANY1 ING)))
DOING:PUP:LIST))))
(RPAQQ ALTERNATIVES:DEFER:DECISION:KNOWLEDGE ((COND ((AND (NOT (MEMBER NIL (MAPCAR (SETQ C (CDADR DEC))
(FUNCTION (LAMBDA (D)
(GETP D BEING))))
))
(SETQ PROC (INVECTOR (PROCEDURE:INTERSECTION
(MAPCAR C (FUNCTION (LAMBDA
(D)
(GETP D
META:CODE)))))
)))
(COND ((EQUAL TASK (INVECTOR (LAST DEC)))
(SETQ TNAME TASK:NAME))
(T (GET:NAME (INVECTOR (LAST DEC))
(VECTOR TNAME))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ TNAME)
TYPE OF (LAST DEC)
IS
(VECTOR TEMPORARILY
(@ PROC)))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (VECTOR (@ TNAME)
TYPE OF
(INVECTOR
(LAST DEC)))
ENCODABLE:SECTION:LIST))
(SETQ UNDEFINED:SECTION:LIST
(SETUNION (SETDIFFERENCE (COND ((LESSP (LENGTH PROC)
3)
(LIST PROC))
(T PROC))
ABLE:PUP:LIST)
UNDEFINED:SECTION:LIST))
(TUPLE PROCEDURE:SUBSET (@ PROC)
ABLE:PUP:LIST))
(T NIL))))
(RPAQQ ALTERNATIVES:RESOLVE:DECISION:KNOWLEDGE NIL)
(RPAQQ AND:LOOP:TERMINATION:KNOWLEDGE (SET RESULT:PLACE
(APPEND (EVAL RESULT:PLACE)
(MAPCONC (CDR (SASSOC (CADR CHOICE)
TRUE:FN:CALL:LIST))
(FUNCTION
(LAMBDA
(FUNC)
(COND
((NOT (NUMBERP (CAR (LAST (COLON:BREAK
(CAR FUNC))))))
NIL)
((SETQ INTSEC (INTERSECTION (COPY
DISTINGUISHED:ARG:LIST)
(CDR FUNC)))
(LIST (LIST (CAR FUNC)
(SASSOC (CAR INTSEC)
DISTINGUISHED:INFO:LIST)
T
(VECTOR T NIL))))
(T (LIST (LIST (CAR FUNC)
T))))))))))
(RPAQQ APPLIED:SO:AS:TO:KEEP APPLIED:SO:AS:TO:KEEP)
(RPAQQ ASSERT:LISTS
(ABLE:PUP:LIST ABLE:USER:LIST ATTEMPTING:ANYTHING:LIST ATTEMPTING:SOMETHING:LIST AWARE:PUP:LIST
AWARE:USER:LIST CODING:WARNING:LIST DEFERRED:DECISION:LIST DISTINGUISHED:ARG:LIST
DISTINGUISHED:INFO:LIST DOING:PUP:LIST ENCODABLE:SECTION:LIST EXECUTABLE:INFO:LIST FN:CALL:LIST
SOME:INSERTIONS:LIST SOME:DELETIONS:LIST FRINGE:CONCIOUS:LIST GLOBAL:INITIALIZATION:LIST
INITIALIZE:VAR:LIST IS:DEFINED:LIST IS:SPECIFIC:LIST IS:STRUCTURE:LIST KNOWN:NAMES
LOOP:TERMINATION:LIST MEMBER:OF:LIST NAMED:EXPRESSION:LIST NEW:INFO:LIST NEW:THING:LIST
PART:INTERSECTION:LIST PARTITIONED:DOMAIN:LIST PLAUSIBLE:NAMES:LIST PUP:SATISFIED:LIST
PUP:STUDIED:LIST PUP:WANTED:LIST PUP:WANTS:LIST READ:USER:LIST RELEVANT:INFO:LIST
RESOLVED:DECISION:LIST RESULT:BINDING:LIST TRANSLATED:INFO:LIST TRANSLATED:PAIR:LIST
TRUE:FN:CALL:LIST TYPE:OF:LIST UNDEFERRED:DECISION:LIST UNDEFINED:SECTION:LIST USABLE:INFO:LIST
USER:WANTS:LIST WRITTEN:PROGRAMS:LIST))
(RPAQQ BEING BEING)
(RPAQQ BOOLEAN:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ BOOLEAN:RESOLVE:DECISION:KNOWLEDGE (PROGN (PUPRIN1 "SINCE THE DECISION IS BOOLEAN, JUST ANSWER YES OR NO.")
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PUPRIN1 "NOW TYPE YOUR ANSWER: ")
(MAPC (CADR (MEMBER (COLON:BACK (TUPLE (PREAD)
RESULTS))
(CADR D)))
(QUOTE EVAL))
(MAPC (CADR (MEMBER BOTH:RESULTS (CADR D)))
(QUOTE EVAL))
(PUPRIN1 "
OK, READY TO MOVE ON NOW.
")))
(RPAQQ BOTH:RESULTS BOTH:RESULTS)
(RPAQQ BREAKUP:LIST (: ; %. , - ? = +))
(RPAQQ CALL CALL)
(RPAQQ COMMENT COMMENT)
(RPAQQ COMPILABLE:BEING:PARTS (META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES EXPLICIT:ARGS
EXPLICIT:ARGS:CHECK IMPLICIT:ARGS DEMONS INHIBIT:CURRENT:DEMONS))
(RPAQQ DEFINITION:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ
DEFINITION:RESOLVE:DECISION:KNOWLEDGE
(PROGN
(SETQ DEFINED:OBJECT (CAR (LAST (CDADR D))))
(COND ((NOT (MEMBER NIL (MAPCAR UNDEFINED:SECTION:LIST (FUNCTION (LAMBDA (US1)
(NOT (COND ((MATCH (VECTOR ANY1 TYPE OF
(LIST VECTOR
DEFINED:OBJECT)
FRAG1)
US1)
(SETQ HOLD:ANY1 ANY1)
(SETQ HOLD:FRAG1 FRAG1)
T))))))))
(SETQ HOLD:ANY1 DEFINED:OBJECT)
(SETQ HOLD:FRAG1 NIL)))
(PUPRIN1 "SINCE THE QUESTION IS ONE OF DEFINITION, PLEASE JUST
TYPE IN THE DEFINITION OF ")
(PUPRIN1 HOLD:ANY1)
(COND
((AND (SETQ TCALL (SASSOC HOLD:ANY1 (OUTVECTOR FN:CALL:LIST)))
(GETP DEFINED:OBJECT PREDICATE))
(PUPRIN1
(CONCAT
"
SINCE THIS IS A PREDICATE, THE EXPRESSION YOU TYPE IN SHOULD BE A
LOGICAL EXPRESSION, WHICH IS TRUE IF "
(CADR TCALL)
" IS OF
THE "
(CDADDR TCALL)
" TYPE, AND SHOULD BE FALSE IF IT ISNT OF
THAT TYPE.
"))))
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PUPRIN1 "USER: ")
(SETQ NEW:INFO:LIST (CONS (VECTOR DEFINE (@ HOLD:ANY1)
AS
(INVECTOR (PREAD)))
NEW:INFO:LIST))))
(RPAQQ DICHOTOMY:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ
DICHOTOMY:RESOLVE:DECISION:KNOWLEDGE
(PROGN (SETQ ENT1 (SASSOC (CADR CHOICE)
(OUTVECTOR FN:CALL:LIST)))
(SETQ ENT2 (CADR ENT1))
(MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (TOL)
(COND ((MATCH (VECTOR ANY1 TYPE OF (LIST VECTOR ENT2)
IS ANY2 AND IS USED IN (CADR CHOICE))
TOL)
(SETQ ARG1 ANY1))))))
(PUPRINT (TUPLE ABOVE, ARG1 REFERS TO (DETERMINE:ARG:VALUE CHOICE)
;ALSO, PLEASE IGNORE THE THIRD 'CHOICE'; IT IS ONLY FOR ME TO LOOK AT))
(COND
((SETQ TRESULT (NLSETQ (EVAL (EVAL (CADDR (CADR D))))))
(SETQ TRESULT (CAR TRESULT))
(PUPRIN1
"
AHA!!!! I'VE RESOLVED IT MYSELF!!! NO NEED TO INTERACT WITH THE SLOW
USER CHANNEL AFTER ALL!!!
"))
(T (PUPRIN1 (CONCAT "
SINCE THE DECISION IS DICHOTOMOUS, TYPE A 1 OR A 2
1 MEANS THAT " (EVAL (CADR (CADDR (CADR D))))
" IS CORRECT.
2 MEANS THAT "
(EVAL (CADDR (CADDR (CADR D))))
" IS CORRECT.
"))
(PERMIT:DETAILED:DECISION)
(PUPRIN1 "
USER: ")
(SETQ TRESULT (EQUAL (PREAD)
1))))
(SETQ NEWPIECE (CDADR (MEMBER RESULTS (CADR D))))
(SETQ NEWPIECE (COND (TRESULT (CAR NEWPIECE))
(T (CADR NEWPIECE))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(INVECTOR (EVAL NEWPIECE)))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
(RPAQQ DOES DOES)
(RPAQQ DOESNT DOESNT)
(RPAQQ DUMMY:ARGUMENT DUMMY:ARGUMENT)
(RPAQQ EQUAL EQUAL)
(RPAQQ EQUALS EQUALS)
(RPAQQ EVAL EVAL)
(RPAQQ EVAL:BEING:PARTS (WHAT HOW WHY AFFECTS SPEC:WHY PREDICATE DATA:STRUCTURE INHIBIT:CURRENT:DEMONS FORM:CHANGING
ENCODABLE NON:EVAL:ARGS NLAMBDA))
(RPAQQ EXPERTAG NIL)
(RPAQQ FALSE FALSE)
(RPAQQ FINAL:PREADLIST
(T YES YES YES YES YES NO YES YES YES T YES YES MODIFY:STRUCTURE:39 YES MODIFY:STRUCTURE:40 YES
MODIFY:STRUCTURE:41 YES MODIFY:STRUCTURE:42))
(RPAQQ FLOW:ASSIGNMENT (COMMENT HER IS THE FLOW ASSIGNMENT, WHICH SHOULD ACTUALLY BE SET BY THE FLOW:PRECEDED ROUTINE)
)
(RPAQQ FOREVER FOREVER)
(RPAQQ FUNDAMENTAL:IDEN:TABLE (((MEMBER (CAR LI)
(QUOTE (AND OR NOT EQUAL LESSP GREATERP MINUSP)))
(APPEND (VECTOR (CAR LI))
(MAPCAR (CDR LI)
TRANSLATE)))
((EQUAL (CAR LI)
(QUOTE COND))
(APPEND (VECTOR COND)
(MAPCAR (CDR LI)
(FUNCTION (LAMBDA (L)
(MAPCAR L TRANSLATE))))))))
(RPAQQ GLOBAL:CONTEXT:0 GLOBAL:CONTEXT:0)
(RPAQQ GO GO)
(RPAQQ HOLD:GLOBALVARS
(BEING:STACK CURRENT:DEMONS USER:INTERRUPT:DEMONS BECAUSE UNKNOWN:TASK BREAKUP:LIST ARG1 ARG2 ARG3 ANY1 ANY2
ANY3 FRAG1 FRAG2 CHOICE TYPE:OF:LIST SATISFY MATCH:RESULT DEMON:STACK))
(RPAQQ INFERIOR INFERIOR)
(RPAQQ ING ING)
(RPAQQ IS IS)
(RPAQQ IS:BEING:LIST
(MAKE:A:GUESS ASK:USER:ABOUT:57 SOME:PART:OF:16 SOME:PART:OF:14 SOME:PART:OF:12 CONDITIONAL:DELETION:56
MODIFY:STRUCTURE:49 CONDITIONAL:INSERTION:55 MODIFY:STRUCTURE:48 CONDITIONAL:INSERTION:54
MODIFY:STRUCTURE:47 CONDITIONAL:INSERTION:53 MODIFY:STRUCTURE:42 CONDITIONAL:DELETION:52
MODIFY:STRUCTURE:41 CONDITIONAL:DELETION:51 MODIFY:STRUCTURE:40 CONDITIONAL:INSERTION:50
MODIFY:STRUCTURE:39 COMPLEX:ALTERATION:46 COMPLEX:ALTERATION:45 CONDITIONAL:INSERTION:44
MODIFY:STRUCTURE:9 SIMPLE:COMPARE:FN:43 BETTER:38 COMPLEX:ALTERATION:32 CONDITIONAL:INSERTION:31
NAME:OF:CLASS SET:OF:POSSIBLE:NAMES:OF:CLASS MAYBE:RELNS:30 NO:RELNS:29 YES:RELNS:28
POSSIBLE:NAME:OF:CLASS:CLASSNAME:21 POSSIBLE:NAME:OF:CLASS:OBJECTS:20 MODIFY:STRUCTURE:7
CONTRADICTS:27 POSSIBLE:NAME:OF:CLASS:RELNS:22 COMPARE:26 COMPARE:25 COMPARE:24 JOIN:23
COMPARE:19 POSSIBLE:NAME:OF:CLASS TEST:18 FOREACH:17 GET:HOLD:OF:8 TAKE:HOLD:OF:6 TAKE:HOLD:OF:3
HAS:NAME:5 ELEMENT:4 STATIC:SCENE:10 PAD:2 CF:1 ADD:DEFINITION ADJECTIVE:HANDLER
ANALYZE:IMPLICATIONS ASK:USER:ABOUT BETTER CHOOSE:FROM CLARIFY:IMPROBABLE:SITUATION
CLASSIFICATORY:CONCEPT:FORMATION COMPARE COMPARITIVE:CONCEPT:FORMATION COMPLEX:ALTERATION
COMPLEX:COMPARE:FN CONCEPT:FORMATION CONDITIONAL:DELETION CONDITIONAL:INSERTION
DATA:STRUCTURE:DELETIONS DATA:STRUCTURE:INSERTIONS DEFER:DECISION ELEMENT ENCODE
EXTRACT:RELEVANT:SUBSET FILL:IN:UNDEFINED:SECTION FOREACH GET:DATA:STRUCTURE GET:HOLD:OF
GET:NAME GET:NEW:INFORMATION IS:OF:TYPE JOINING:FUNCTION LIST:STRUCTURE MAKE:ENCODABLE
MAKE:NEW:BEING MESSAGE METRICAL:CONCEPT:FORMATION MODIFY:STRUCTURE OBTAIN:USABLE:INFORMATION
PARTITION:A:DOMAIN PARTITION:BY:TAKE:CLASS:GET:ELE PARTITION:BY:TAKE:ELE:AND:CLASS
PARTITION:BY:TAKE:ELE:GET:CLASS PROBABILITY=0:# PROBABILITY=1:# PROBABILITY>0&<1:#
PROPOSE:PLAUSIBLE:NAMES RECOGNIZE:# RECOGNIZE:ARGS RECOGNIZE:CAR RECOGNIZE:CONDITIONAL
RECOGNIZE:CONJUNCTION RECOGNIZE:EQUALITY RECOGNIZE:FUNCTION:RETURNS RECOGNIZE:INCLUSION
RECOGNIZE:LITERALS RECOGNIZE:SET:RELATIONS RECOGNIZE:SOME:MEMBER REINVESTIGATE:DECISION
REPEATEDLY RESOLVE:DECISION SATISFY SCENE SEARCH SERVE SIMPLE:COMPARE:FN SOME:PART:OF STUDY:TYPE
TAKE:HOLD:OF TEST TRANSLATE USE:INFORMATION UTILIZE WHEN:NEXT WRITE:PROGRAM))
(RPAQQ ISNT ISNT)
(RPAQQ KNOWLEDGE KNOWLEDGE)
(RPAQQ LABEL:COUNTER 2)
(RPAQQ LIST:VALUE:SETUP
(INVECTOR (LIST (QUOTE INITIALIZE)
(TUPLE SETQ (@ SNAME)
(PROGN (SETQ CODING:WARNING:LIST
(NCONC1 CODING:WARNING:LIST
(TUPLE 97 VECTOR COMMENT WARNING INITIAL:VALUE IN (@ SNAME)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY NIL SINCE
(VECTOR WE KNOW NONE TO BEING WITH; THE LIST STRUCTURE
SHOULD GROW WITH TIME))))
(QUOTE INITIAL:VALUE)))
(QUOTE ACCESS)
SNAME
(QUOTE INSERT)
(TUPLE (TUPLE LAMBDA (TUPLE X)
(LIST (QUOTE COND)
(LIST (TUPLE ATOM X)
(LIST (QUOTE SETQ)
SNAME
(TUPLE MERGE:IN X (@ SNAME)
BETTER)))
(LIST T (LIST (QUOTE SETQ)
SNAME
(TUPLE MERGE (TUPLE COPY X)
(LIST (QUOTE COPY)
SNAME)
BETTER)))))
INSERTS X INTO (@ SNAME))
(QUOTE DELETE)
(TUPLE (TUPLE LAMBDA (TUPLE X)
(LIST (QUOTE COND)
(LIST (TUPLE ATOM X)
(LIST (QUOTE SETQ)
SNAME
(TUPLE PULLOUT X (@ SNAME))))
(LIST T (LIST (QUOTE SETQ)
SNAME
(TUPLE SETDIFFERENCE (@ SNAME)
X)))))
DELETES X FROM (@ SNAME)))))
(RPAQQ MASTER:PREADLIST (0 (WRITE A PROGRAM WHICH DOES CONCEPT FORMATION)
CF NO NO PAD NO (A C)
NIL NIL HAS:NAME YES YES NO NIL NIL NIL NO NIL NO (A DESCRIPTION OF A STATIC SCENE)
NIL NO (THE FRONT PART OF ARG1 ISNT ???)
YES NO T NIL ELEMENT:OBJECTS NIL ELEMENT:CLASSNAME NO NIL ELEMENT:RELNS NO NIL T NO NO
(B)
NO NO NIL NIL NO YES (TEST SUCCEEDED)
NIL JOIN NO NIL NO NIL NO NIL NO (ANY RELATION IN POSSIBLE:NAME:OF:CLASS:RELNS:22 IS
INCOMPATIBLE WITH ELEMENT:RELNS:15)
CONTRADICTS NO (A B C)
YES YES:RELNS NO:RELNS MAYBE:RELNS NO (A C)
NIL NIL CLASS:OBJECTS CLASS:CLASSNAME CLASS:YES:RELNS CLASS:NO:RELNS CLASS:MAYBE:RELNS YES
NO YES ARG1 (RESULT:2 ISNT NOTHING)
YES T NIL YES YES YES NO YES YES YES NIL NO NIL NO NIL NO NIL NO NIL NO 1 NIL NO T NO 1 NO
(A C)
NO NIL NO NIL NO YES ARG1 (RESULT:3 ISNT NOTHING)
T YES YES YES YES YES NO YES YES YES T YES YES MODIFY:STRUCTURE:39 YES MODIFY:STRUCTURE:40
YES MODIFY:STRUCTURE:41 YES MODIFY:STRUCTURE:42 YES (A)
NO NIL))
(RPAQQ MINOR:WORDS (A AT DO DOES FOR IN PROGRAM THE TO WHICH WHILE WRITE))
(RPAQQ NAME NAME)
(RPAQQ NEW:P:NUMBER 1944)
(RPAQQ NO:RESULTS NO:RESULTS)
(RPAQQ NON:EVAL:BEING:PARTS (IDEN IMPLICIT:ARGS EXPLICIT:ARGS WHEN META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES
POST:REQUISITES EXPLICIT:ARGS:CHECK DEMONS MAIN:EFFECTS MINOR:EFFECTS
COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS ALTERNATIVES))
(RPAQQ NON:EXECUTABLE NON:EXECUTABLE)
(RPAQQ NOT:TIME:YET NOT:TIME:YET)
(RPAQQ OLD:PREADLIST (0 (WRITE A PROGRAM WHICH DOES CONCEPT FORMATION)
CF NO NO PAD NO (A C)
NIL NIL HAS:NAME YES YES NO NIL NIL NIL NO NIL NO (A DESCRIPTION OF A STATIC SCENE)
NIL NO (THE FRONT PART OF ARG1 ISNT ???)
YES NO T NIL ELEMENT:OBJECTS NIL ELEMENT:CLASSNAME NO NIL ELEMENT:RELNS NO NIL T NO NO
(B)
NO NO NIL NIL NO YES (TEST SUCCEEDED)
NIL JOIN NO NIL NO NIL NO NIL NO (ANY RELATION IN POSSIBLE:NAME:OF:CLASS:RELNS:22 IS
INCOMPATIBLE WITH ELEMENT:RELNS:15)
CONTRADICTS NO (A B C)
YES YES:RELNS NO:RELNS MAYBE:RELNS NO (A C)
NIL NIL CLASS:OBJECTS CLASS:CLASSNAME CLASS:YES:RELNS CLASS:NO:RELNS CLASS:MAYBE:RELNS YES NO
YES ARG1 (RESULT:2 ISNT NOTHING)
YES T NIL YES YES YES NO YES YES YES NIL NO NIL NO NIL NO NIL NO NIL NO 1 NIL NO T NO 1 NO
(A C)
NO NIL NO NIL NO YES ARG1 (RESULT:3 ISNT NOTHING)))
(RPAQQ ONETYPE ONETYPE)
(RPAQQ ONETYPE:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ ONETYPE:RESOLVE:DECISION:KNOWLEDGE (PROGN (SETQ TYPE:OF:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR
(LAST (CADR D)))
IS
(EVAL (CADR (MEMBER RESULTS
(CADR D)))))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
(RPAQQ PARTS PARTS)
(RPAQQ PERMANENT:KNOWN:NAMES NIL)
(RPAQQ POSSIBLE POSSIBLE)
(RPAQQ PREADLIST NIL)
(RPAQQ PREDICATE:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ PREDICATE:RESOLVE:DECISION:KNOWLEDGE
(PROGN (SETQ F:CALL (SASSOC (CADR CHOICE)
(OUTVECTOR FN:CALL:LIST)))
(SETQ OUTER:FN (CAR (LAST F:CALL)))
(SETQ RESULT:PLACE (CADR (MEMBER RESULTS (CADR D))))
(SETQ IS:DONE (SASSOC (CADR CHOICE)
(EVAL RESULT:PLACE)))
(COND ((EVAL (CADR IS:DONE))
(PUPRIN1 "
AHA!! I'VE RESOLVED THIS PREDICATE-GETTING DECISION MYSELF.
"))
(T (PUPRIN1 "
PLEASE TYPE IN A LOGICAL EXPRESSION WHICH IS TRUE ")
(PUPRIN1 (CADR (MEMBER PREDICATE (CADR D))))
(PUPRIN1 " AND IS FALSE OTHERWISE.
")
(PERMIT:DETAILED:DECISION)
(PUPRIN1 "
USER: ")
(SETQ RESPONSE (OUTVECTOR (TRANSLATE (INVECTOR (PREAD))
T)))
(SETQ A:COUNT 0)
(SETQ TFN (APPLY* (OUTVECTOR (CADR (MEMBER HOW (CADR D))))
RESPONSE))
(COND ((MATCH (TUPLE DO UNTIL (TUPLE FORSOME ANY1 IN ANY2 FRAG1))
RESPONSE)
(SETQ DISTINGUISHED:ARG:LIST (CONS ANY2 DISTINGUISHED:ARG:LIST))
(SETQ DISTINGUISHED:INFO:LIST (CONS (LIST ANY2 (CADDR RESPONSE))
DISTINGUISHED:INFO:LIST))
(SETQ MEMBER:OF:LIST (CONS (LIST ANY1 ANY2)
MEMBER:OF:LIST))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(APPEND (LIST VECTOR TFN)
(MAPCAR (CDR F:CALL)
(FUNCTION (LAMBDA
(DUMMY:ARG)
(PACK (TUPLE ARG (SETQ
A:COUNT
(ADD1 A:COUNT))))))
)))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))
(SETQ BRESULT (COLON:BREAK RESULT:PLACE))
(EVAL (EVAL (COLON:BACK (LIST TFN (CAR BRESULT)
(CADR BRESULT)
(QUOTE KNOWLEDGE)))))))))
(RPAQQ PRIMITIVE:PROGRAMS:LIST
(AND OR NOT COND T MAPC MAPCAR LAMBDA FUNCTION PLUS TIMES MERGE:IN LIST APPEND CONS CAR CDR CADR CADDR CADDDR
CADAR MINUS MINUSP QUOTIENT ADD1 SUB1 SET SETQ NULL QUOTE EVAL LESSP EQUAL TEMPORARILY NIL RELEVANT
IRRELEVANT PROG PROGN CDAR CDDR CAAR CAADR CAAAR CDADR PROG1 PREAD PUPRINT PUPRIN1 PRIN2 PRIN1 PRINT READ
RATOM COPY MERGE))
(RPAQQ PRIMITIVE:VARS:LIST (T NIL 0 1 2 3 4 5 6 7 8 9 10 -1 -2 -3))
(RPAQQ PROGRAM:WRITING:PHASES (OBTAIN:USABLE:INFORMATION USE:INFORMATION FILL:IN:UNDEFINED:SECTION
ADAPT:PRECONCIVED:FUNCTION CLARIFY:IMPROBABLE:SITUATION
FIX:INCORRECT:PIECE OPTIMIZE))
(RPAQQ
PROPERTY:LIST:SETUP
(PROGN
(PUPRIN1
(CONCAT
"
I HAVE DECIDED TO KEEP " SNAME
" STRUCTURED USING THE PROPERTY LIST
FEATURE OF LISP. FOR THIS REASON, I NEED TO HAVE A NAME FOR EACH
PROPERTY (CORRESPONDING TO EACH SUBPART OF " SNAME ") :
"))
(SETQ SCODENAMES (MAPCAR (CDR SCODE)
(QUOTE CADDR)))
(SETQ PROPNAMES (MAPCAR (CDR SCODE)
(FUNCTION (LAMBDA (POS)
(SETQQ CNAME CNAME)
(GET:NAME (INVECTOR POS)
(VECTOR CNAME))
(SETQ GLOBAL:INITIALIZATION:LIST (CONS (LIST (QUOTE SETQQ)
CNAME CNAME)
GLOBAL:INITIALIZATION:LIST))
CNAME))))
(SETQ ACCESS:PART (MAP2CAR SCODENAMES PROPNAMES (FUNCTION (LAMBDA (PROP PROPNAME)
(TUPLE (TUPLE GETP (@ SNAME)
(@ PROPNAME))
ACCESSES
(@ PROP))))))
(SETQ INSERT:PART (MAP2CAR SCODENAMES PROPNAMES (FUNCTION (LAMBDA
(PROP PROPNAME)
(TUPLE (TUPLE LAMBDA (TUPLE X)
(LIST (QUOTE PUT)
SNAME PROPNAME
(TUPLE MERGE:IN X
(LIST (QUOTE GETP)
SNAME PROPNAME)
BETTER)))
INSERTS X INTO (@ PROP))))))
(SETQ INIT:PART
(MAP2CAR SCODENAMES PROPNAMES
(FUNCTION (LAMBDA (PROP PROPNAME)
(SETQ CODING:WARNING:LIST
(CONS (TUPLE 50 VECTOR COMMENT (PACK (LIST (QUOTE INITIAL:VALUE:OF:)
PROPNAME))
IN
(@ SNAME)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY NIL OR SOME
ALREADY-READ-IN VALUE SINCE
(VECTOR INITIAL VALUES ARE RARELY COMPUTED INTRICATELY; THEY
ARE TYPICALLY CONSTANT, OFTEN NIL, OR ARE READ IN AT
THE BEGINNING))
CODING:WARNING:LIST))
(TUPLE (LIST (QUOTE PUT)
SNAME PROPNAME (PACK (LIST (QUOTE INITIAL:VALUE:OF:)
PROP)))
INITIALIZES
(@ PROP))))))
(SETQ DELETE:PART (MAP2CAR SCODENAMES PROPNAMES (FUNCTION (LAMBDA
(PROP PROPNAME)
(TUPLE (TUPLE LAMBDA (TUPLE X)
(LIST (QUOTE PUT)
SNAME PROPNAME
(TUPLE PULLOUT X
(LIST (QUOTE GETP)
SNAME PROPNAME))))
DELETES X FROM (@ PROP))))))
(MAPC (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B IPART BFLAT)
(SETQ IPART (SETINTERSECTION (APPEND SCODENAMES)
(APPEND (SETQ BFLAT (FLATTEN (GETP B META:CODE))))))
(SETQ CODE (GETP B META:CODE))
(MAP2C SCODENAMES PROPNAMES (FUNCTION
(LAMBDA (PROP PROPNAME)
(COND ((MEMBER PROP IPART)
(SETQ CODE (COND ((EQUAL (CAR CODE)
(QUOTE PROGN))
(APPEND (TUPLE (CAR CODE)
(TUPLE SETQ (@ PROP)
(TUPLE GETP ARG1
(@ PROPNAME))))
(CDR CODE)))
(T (LIST (QUOTE PROGN)
(TUPLE SETQ (@ PROP)
(TUPLE GETP ARG1 (@ PROPNAME)))
CODE)))))))))
(COND ((AND IPART (MATCH (TUPLE ARG1 IS INSTANTIATED AS (@ ENAME))
(MEMBER (QUOTE ARG1)
BFLAT))
(NOT (MEMBER (CAR CODE)
(VECTOR COMMENT STRUCTURE))))
(SETQ ARG:LIST (GETP B EXPLICIT:ARGS))
(SETQ FARGS NIL)
(PUT B META:CODE (GETCODE CODE B -1)))))))
(PROG (CODE FNAME BNAME)
(SETQ CODE (STRUCTURE LIST ATOMS))
(SETQ BNAME LIST:STRUCTURE)
(SETQ IS:STRUCTURE:LIST (APPEND IS:STRUCTURE:LIST SCODENAMES (MAPCAR SCODENAMES (FUNCTION (LAMBDA
(SN)
(LIST VECTOR SN
NIL))))))
(MAP2C SCODENAMES PROPNAMES (FUNCTION (LAMBDA
(PROP PROPNAME)
(SETQ FNAME PROP)
(SATISFY (VECTOR IS BEING FNAME))
(PUT PROP DATA:STRUCTURE
(VECTOR INITIALIZE (LIST (QUOTE PUT)
SNAME PROPNAME
(PACK (LIST (QUOTE INITIAL:VALUE:OF:)
PROP)))
ACCESS
(LIST (QUOTE GETP)
SNAME PROPNAME)
INSERT
(TUPLE (TUPLE LAMBDA (TUPLE X)
(LIST (QUOTE PUT)
SNAME PROPNAME
(TUPLE MERGE:IN X
(LIST (QUOTE GETP)
SNAME PROPNAME)
BETTER)))
INSERTS X INTO (@ PROP))
DELETE
(TUPLE (TUPLE LAMBDA (TUPLE X)
(LIST (QUOTE PUT)
SNAME PROPNAME
(TUPLE PULLOUT X
(LIST (QUOTE GETP)
SNAME PROPNAME))))
DELETES X FROM (@ PROP))))))))
(INVECTOR (LIST (QUOTE INITIALIZE)
INIT:PART
(QUOTE ACCESS)
ACCESS:PART
(QUOTE INSERT)
INSERT:PART
(QUOTE DELETE)
DELETE:PART))))
(RPAQQ RESULT:COUNTER 10)
(RPAQQ RESULTS RESULTS)
(RPAQQ SET:OF SET:OF)
(RPAQQ SET:OF:BEING:PARTS
(IDEN IMPLICIT:ARGS EXPLICIT:ARGS EXPLICIT:ARGS:CHECK NLAMBDA NON:EVAL:ARGS WHAT HOW WHY SPEC:WHY MAIN:EFFECTS
MINOR:EFFECTS WHEN META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES POST:REQUISITES DEMONS AFFECTS
COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS ALTERNATIVES PREDICATE DATA:STRUCTURE ENCODABLE
INHIBIT:CURRENT:DEMONS FORM:CHANGING))
(RPAQQ SET:OF:BEINGS
(ADD:DEFINITION ADJECTIVE:HANDLER ANALYZE:IMPLICATIONS ASK:USER:ABOUT BETTER CHOOSE:FROM
CLARIFY:IMPROBABLE:SITUATION CLASSIFICATORY:CONCEPT:FORMATION COMPARE
COMPARITIVE:CONCEPT:FORMATION COMPLEX:ALTERATION COMPLEX:COMPARE:FN CONCEPT:FORMATION
CONDITIONAL:DELETION CONDITIONAL:INSERTION DATA:STRUCTURE:DELETIONS DATA:STRUCTURE:INSERTIONS
DEFER:DECISION ELEMENT ENCODE EXTRACT:RELEVANT:SUBSET FILL:IN:UNDEFINED:SECTION FOREACH
GET:DATA:STRUCTURE GET:HOLD:OF GET:NAME GET:NEW:INFORMATION IS:OF:TYPE JOINING:FUNCTION
LIST:STRUCTURE MAKE:A:GUESS MAKE:ENCODABLE MAKE:NEW:BEING MESSAGE METRICAL:CONCEPT:FORMATION
MODIFY:STRUCTURE OBTAIN:USABLE:INFORMATION PARTITION:A:DOMAIN PARTITION:BY:TAKE:CLASS:GET:ELE
PARTITION:BY:TAKE:ELE:AND:CLASS PARTITION:BY:TAKE:ELE:GET:CLASS PROBABILITY=0:#
PROBABILITY=1:# PROBABILITY>0&<1:# PROPOSE:PLAUSIBLE:NAMES RECOGNIZE:# RECOGNIZE:ARGS
RECOGNIZE:CAR RECOGNIZE:CONDITIONAL RECOGNIZE:CONJUNCTION RECOGNIZE:EQUALITY
RECOGNIZE:FUNCTION:RETURNS RECOGNIZE:INCLUSION RECOGNIZE:LITERALS RECOGNIZE:SET:RELATIONS
RECOGNIZE:SOME:MEMBER REINVESTIGATE:DECISION REPEATEDLY RESOLVE:DECISION SATISFY SCENE SEARCH
SERVE SIMPLE:COMPARE:FN SOME:PART:OF STUDY:TYPE TAKE:HOLD:OF TEST TRANSLATE USE:INFORMATION
UTILIZE WHEN:NEXT WRITE:PROGRAM))
(RPAQQ SINCE SINCE)
(RPAQQ SNAP SNAP)
(RPAQQ SNAPFNS NIL)
(RPAQQ SNAPVARS
(EXPERTAG OLD:PREADLIST FINAL:PREADLIST PREADLIST ABLE:PUP:LIST ABLE:USER:LIST ANY1 ANY2 ANY3 ARG1 ARG2 ARG3
ATTEMPTING:ANYTHING:LIST ATTEMPTING:SOMETHING:LIST AWARE:USER:LIST BECAUSE BEING:STACK CHOICE
CODING:WARNING:LIST CURRENT:DEMONS DEFERRED:DECISION:LIST DEMON:STACK DISTINGUISHED:ARG:LIST
DISTINGUISHED:INFO:LIST DOING:PUP:LIST ENCODABLE:SECTION:LIST EXECUTABLE:INFO:LIST FN:CALL:LIST
FRAG1 FRAG2 FRINGE:CONCIOUS:LIST GLOBAL:INITIALIZATION:LIST INITIALIZE:VAR:LIST IS:BEING:LIST
IS:DEFINED:LIST IS:SPECIFIC:LIST IS:STRUCTURE:LIST KNOWN:NAMES LOOP:TERMINATION:LIST MATCH:RESULT
MEMBER:OF:LIST NAMED:EXPRESSION:LIST NEW:INFO:LIST NEW:THING:LIST PART:INTERSECTION:LIST
PARTITIONED:DOMAIN:LIST PLAUSIBLE:NAMES:LIST PUP:STUDIED:LIST PUP:WANTED:LIST PUP:WANTS:LIST
READ:USER:LIST RELEVANT:INFO:LIST RESULT:BINDING:LIST RESULT:COUNTER NEW:F:NUMBER NEW:P:NUMBER
SET:OF:BEINGS TRANSLATED:INFO:LIST TRANSLATED:PAIR:LIST TRUE:FN:CALL:LIST TYPE:OF:LIST
UNDEFERRED:DECISION:LIST UNDEFINED:SECTION:LIST UNKNOWN:TASK USABLE:INFO:LIST USER:INTERRUPT:DEMONS
USER:WANTS:LIST WRITTEN:PROGRAMS:LIST (COMS * (LIST (APPEND (QUOTE (PROP ALL))
(SETDIFFERENCE IS:BEING:LIST
SET:OF:BEINGS))))
(P (PRIN1 " WARNING: NEW BEINGS ARE NOT SEMICOMPILED ")
(MAPC IS:BEING:LIST (FUNCTION (LAMBDA (B)
(SET B B)))))))
(RPAQQ SOMEOF:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ SOMEOF:RESOLVE:DECISION:KNOWLEDGE
(PROG (IN:SET:TRANS)
(PUPRIN1 "SINCE THE DECISION IS SOME:OF, TYPE ANY NON-NULL SUBSET OF: ")
(TERPRI)
(MAP2C (CDAR (CDDADR D))
(QUOTE (A B C D E F))
(FUNCTION (LAMBDA (D1 L1)
(PUPRINT (LIST L1 (QUOTE ....)
D1)))))
(PUPRIN1 "
FOR EXAMPLE, (B D) WOULD MEAN THAT THE 2ND AND 4TH ITEMS ARE RELEVANT")
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PUPRIN1 "USER: ")
(SETQ IN:SET (PREAD))
(MAP2C (QUOTE (A B C D E F))
(CDAR (CDDADR D))
(FUNCTION (LAMBDA (L1 D1)
(COND ((MEMBER L1 IN:SET)
(SETQ IN:SET:TRANS (NCONC1 IN:SET:TRANS D1)))))))
(COND ((GREATERP (LENGTH (SETQ PROC (PROCEDURE:INTERSECTION (SETQ T0 (MAPCAR IN:SET:TRANS
(FUNCTION
(LAMBDA
(B)
(MAPC (GETP B COMMENTS)
(QUOTE EVAL))
(INSTANTIATE
(GETP B META:CODE)))))
))))
2)
(SETQ T1 (COND ((EQUAL (CAR PROC)
(QUOTE PROGN))
(MEMBER (CADR PROC)
(CAR T0)))
(T (MEMBER (CAR PROC)
(CAR T0)))))
(SETQ T2 (LDIFF T1 (MEMBER (CAR (LAST PROC))
T1)))
(SETQ T3 (SETDIFFERENCE T2 PROC))
(COND (T3 (SETQ PROC (CAR T1))))
PROC))
(STRUCTURE:INDUCING:DEMON (SETQ OUTERLIST (CADR (SASSOC ARG1 MEMBER:OF:LIST)))
(SETQ PIECES (MAPCAR (CDAR (CDDADR D))
(FUNCTION (LAMBDA (PIECE)
(COLON:BACK (LIST PIECE (QUOTE PART:OF)
OUTERLIST)))))))
(SETQ TYPE:OF:LIST
(CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(COND ((LESSP (LENGTH IN:SET:TRANS)
2)
(MAPC (GETP (CAR IN:SET:TRANS)
COMMENTS)
(QUOTE EVAL))
(INSTANTIATE (GETP (CAR IN:SET:TRANS)
META:CODE)))
(T (VECTOR (COND ((GETP (CAR (LAST (CADR D)))
PREDICATE)
(QUOTE PROGN))
(T (QUOTE REPEATEDLY)))
(INVECTOR PROC)
(APPEND (VECTOR COND)
(MAP2CAR IN:SET:TRANS PIECES
(FUNCTION
(LAMBDA
(IST PIECE)
(MAPC (GETP IST COMMENTS)
(QUOTE EVAL))
(VECTOR
(COND ((EQUAL (LAST IN:SET:TRANS)
(LIST IST))
T)
(STAG (VECTOR MEMBER ARG1
(@ PIECE)))
(T (VECTOR IS:OF:TYPE
(COND ((CADDR (INVECTOR
PROC)))
((QUOTE ARG1)))
(LIST VECTOR COMMENT IST))))
(INVECTOR (PROCEDURE:PULLOUT
PROC
(INSTANTIATE (GETP IST META:CODE)
))))))))))))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D))))
ENCODABLE:SECTION:LIST))))
(RPAQQ STICKY:BNAME MAKE:A:GUESS)
(RPAQQ STICKY:BPART IDEN)
(RPAQQ SUBSETOF:DEFER:DECISION:KNOWLEDGE NIL)
(RPAQQ SUBSETOF:RESOLVE:DECISION:KNOWLEDGE
(PROG (IN:SET:TRANS)
(PUPRIN1 "SINCE THE DECISION IS SUBSET:OF, TYPE ANY NON-NULL SUBSET OF: ")
(TERPRI)
(MAP2C (CDAR (CDDADR D))
(QUOTE (A B C D E F))
(FUNCTION (LAMBDA (D1 L1)
(PUPRINT (LIST L1 (QUOTE ....)
D1)))))
(PUPRIN1 "
FOR EXAMPLE, (B D) WOULD MEAN THAT THE 2ND AND 4TH ITEMS ARE RELEVANT")
(PERMIT:DETAILED:DECISION)
(TERPRI)
(PUPRIN1 "USER: ")
(SETQ IN:SET (PREAD))
(MAP2C (QUOTE (A B C D E F))
(CDAR (CDDADR D))
(FUNCTION (LAMBDA (L1 D1)
(COND ((MEMBER L1 IN:SET)
(SETQ IN:SET:TRANS (NCONC1 IN:SET:TRANS D1)))))))
(SETQ TYPE:OF:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(APPEND (VECTOR PROGN)
(MAPCAR IN:SET:TRANS (FUNCTION (LAMBDA
(IST)
(APPEND (LIST VECTOR IST)
(COND
(ARG1 (TUPLE ARG1)))
(COND
(ARG2 (TUPLE ARG2))))
)))))
TYPE:OF:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D))))
ENCODABLE:SECTION:LIST))))
(RPAQQ SUPERIOR SUPERIOR)
(RPAQQ TRIVIAL:BEING:LIST (IN DO))
(RPAQQ UNKNOWN UNKNOWN)
(RPAQQ UNTIL UNTIL)
(RPAQQ WHEN:ALL WHEN:ALL)
(RPAQQ WHEN:ALL:DEFER:DECISION:KNOWLEDGE
(((VECTOR BEFORE DECIDING FIRMLY HOW TO ANY1 FRAG2)
(TUPLE MEMBER (APPEND (VECTOR DETAIL OF (PACK (LIST ANY1 ING)))
FRAG2)
DOING:PUP:LIST))
((VECTOR BEFORE ANY FRAG2 ROUTINES ARE FINALIZED)
(COND ((MEMBER FRAG2 (QUOTE (NIL (NEW)
(MORE)
(OTHER))))
(TUPLE SETINTERSECTION UNDEFINED:SECTION:LIST DOING:PUP:LIST))
(FRAG2 (TUPLE MEMBER T (TUPLE MAPCAR (TUPLE SETINTERSECTION UNDEFINED:SECTION:LIST DOING:PUP:LIST)
(TUPLE FUNCTION (TUPLE LAMBDA (TUPLE X)
(TUPLE AND (TUPLE OR (TUPLE ATOM X)
(TUPLE SETQ X
(TUPLE CADR
(TUPLE CADDDR X)))
)
(TUPLE OR (TUPLE EQUAL FRAG2 (TUPLE LIST X)
)
(TUPLE SETINTERSECTION
(INTUPLE FRAG2)
(TUPLE GETP X
GENERALIZATIONS)))))))
))))
((VECTOR AFTER ALL FRAG2 ROUTINES ARE FINALIZED)
(COND ((MEMBER FRAG2 (QUOTE (NIL (NEW)
(OTHER)
(THE))))
(TUPLE NULL UNDEFINED:SECTION:LIST))
(T (TUPLE NOT (TUPLE MEMBER (TUPLE CAR FRAG2)
(TUPLE FLATTEN UNDEFINED:SECTION:LIST))))))))
(RPAQQ YES YES)
(RPAQQ YES:RESULTS YES:RESULTS)
(PUTPROPS ADD:DEFINITION BEING T
IDEN (((MATCH (TUPLE DEFINE ANY1 AS ANY2)
LI)
(VECTOR ADD:DEFINITION (@ ANY1)
(TRANSLATE ANY2 T)))
((MATCH (TUPLE ADD DEFINITION ANY1 AS ANY2)
LI)
(VECTOR ADD:DEFINITION (@ ANY1)
(TRANSLATE ANY2 T))))
EXPLICIT:ARGS (OBJECT DEFINITION)
EXPLICIT:ARGS:CHECK (ATOM OBJECT)
WHAT (TUPLE ADD THE DEFINITION OF (@ OBJECT)
AS
(@ DEFINITION)
TO PUP'S KNOWLEDGE)
HOW (TUPLE TRIVIALLY, ADD THE DEFN. TO EXISTING DEFNS.)
WHY (TUPLE THE OBJECT (@ OBJECT)
HAS BEEN REFERENCED, AND PUP FEELS UNCOMFORTABLE DISCUSSING ENTITIES IT CAN'T
DEFINE)
META:CODE (PROGN (SETQ ENCODABLE:SECTION:LIST (CONS OBJECT ENCODABLE:SECTION:LIST))
(SETQ TYPE:OF:LIST (MAPCAR TYPE:OF:LIST (FUNCTION
(LAMBDA (TOL)
(COND ((MATCH (VECTOR (@ OBJECT)
TYPE OF ANY1 IS
FRAG1 USED IN
ANY2)
TOL)
(VECTOR (@ OBJECT)
TYPE OF (@ ANY1)
IS
(@ DEFINITION)
AND IS USED IN
(@ ANY2)))
(T TOL))))))
(SETQ IS:DEFINED:LIST (NCONC1 IS:DEFINED:LIST (VECTOR (@ OBJECT)
IS
(@ DEFINITION)))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
NON:EVAL:ARGS T)
(PUTPROPS ADJECTIVE:HANDLER BEING T
IDEN (((MATCH (TUPLE A DESCRIPTION OF A FRAG1)
LI)
(TRANSLATE (INVECTOR FRAG1)
T))
((MEMBER (CAR LI)
ADJECTIVES)
(ADJECTIVE:HANDLER (CAR LI)
(APPEND (VECTOR TUPLE)
(CDR (TRANSLATE (INVECTOR (CDR LI))
T))))))
IMPLICIT:ARGS (TNAME BNAME CODE TCODE MCODE)
EXPLICIT:ARGS (ADJ NOUN:GROUP)
EXPLICIT:ARGS:CHECK (MEMBER ADJ ADJECTIVES)
WHAT (TUPLE HANDLE THE ADJECTIVE (@ ADJ)
MODIFYING THE NOUN GROUP (@ NOUN:GROUP))
HOW (TUPLE LOOK AT (@ NOUN:GROUP)
AND SELECT THOSE PARTS WHICH ARE NOT CONTRADICTED BY THE ADJECTIVE
(@ ADJ))
WHY (TUPLE BECAUSE THE (@ ADJ)
PARTS OF (@ NOUN:GROUP)
ARE WANTED, AND THE (OPPOSITE ADJ)
PARTS ARE UNWANTED)
META:CODE (PROGN (SETQ FARGS NIL)
(SETQ BNAME (CAR (LAST NOUN:GROUP)))
(SETQ MCODE (GETP BNAME META:CODE))
(SETQ CODE (COND ((SETQ TCODE (SASSOC (OPPOSITE ADJ)
MCODE))
(PROCEDURE:PULLOUT TCODE MCODE))
((SETQ TCODE (SASSOC ADJ MCODE))
(CONS (CAR MCODE)
(CDR TCODE)))
(T MCODE))))
PRE:REQUISITES ((VECTOR NAMED EXPRESSION (INVECTOR (OUTTUPLE (CONS ADJ NOUN:GROUP)))
(SETQQ TNAME TNAME)))
POST:REQUISITES ((VECTOR IS BEING (@ TNAME)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
COMMENTS ((SET TNAME TNAME)))
(PUTPROPS ANALYZE:IMPLICATIONS IDEN (((AND (EQUAL (CAR LI)
ANALYZE:IMPLICATIONS)
(EQUAL (LENGTH (CDR LI))
1))
(VECTOR ANALYZE:IMPLICATIONS (TRANSLATE (CADR LI)
T))))
BEING T
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE ANALYZE THE IMPLICATIONS OF SOME OF THE NEW INFORMATION (@ NEW:INFO))
HOW (TUPLE BY LOCALIZING THE EFFECTS OF THE NEW INFO AND STUDYING THEM)
WHY (TUPLE TO IMPROVE THE UNDERSTANDING THAT PUP HAS OF THE NEW INFORMATION
(@ NEW:INFO))
WHEN (((SETQ ANY1 (CAR USABLE:INFO:LIST))
-60
(TUPLE BECAUSE WE SHOULD USE (@ ANY1)
BEFORE WORRYING ABOUT (@ NEW:INFO)))
(T (DIFFERENCE 50 (SIZE NEW:INFO))
(TUPLE BECAUSE THE SIZE OF THE NEW INFORMATION (@ NEW:INFO)
AFFECTS HOW EASILY AND FRUITFULLY AN ANALYSIS OF IT WILL BE)))
META:CODE (PROGN (LOCATE:AFFECTED:AREA NEW:INFO)
(PREDICT:AFFECT NEW:INFO)
(EVALUATE:AFFECT NEW:INFO))
EXPLICIT:ARGS:CHECK (MEMBER NEW:INFO RELEVANT:INFO:LIST)
MAIN:EFFECTS (((VECTOR AWARE PUP (VECTOR IMPLICATIONS ANY1))
(VECTOR ANALYZE:IMPLICATIONS (@ ANY1))))
AFFECTS (QUOTE ((LOCATE AFFECTED:AREA CALLED)
(PREDICT:AFFECT CALLED)
(EVALUATE:AFFECT CALLED)))
COMPLEXITY:VECTOR (.4 .7 .7 .5 .1))
(PUTPROPS ASK:USER:ABOUT BEING T
IMPLICIT:ARGS (DTYPE IN:SET IN:SET:TRANS TEMPFNVAL)
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE ASK THE USER TO RESOLVE DECISION (@ D))
HOW (TUPLE ASK THE USER WHAT THE RESOLUTION IS)
WHY (TUPLE BECAUSE PUP CANNOT RESOLVE IT, BUT MUST AT THIS TIME)
META:CODE (PROGN (DETERMINE:ARG:VALUE CHOICE)
(DETERMINE:ARG2:VALUE CHOICE)
(TERPRI)
(SETQ DTYPE (CADADR D))
(PUPRIN1 "PUP: SORRY TO BOTHER YOU, BUT I CAN NO LONGER DEFER THIS ")
(PUPRIN1 DTYPE)
(PUPRIN1 " DECISION:")
(PUPRIN1 (CDAR (CDDADR D)))
(COND ((MEMBER (CADR CHOICE)
ENCODABLE:SECTION:LIST))
(T (SETQ TEMPFNVAL (EVAL (EVAL (COLON:BACK (LIST DTYPE (CADR
BEING:STACK)
KNOWLEDGE)))))
(COND ((STRINGP TEMPFNVAL)
T)
(T TEMPFNVAL)))))
COMPLEXITY:VECTOR (.6 .6 .6 .6 .1)
IDEN (((MATCH (TUPLE ASK ME FOR FRAG1)
LI)
(VECTOR ASK:USER:ABOUT (VECTOR QUOTE (COLON:BACK FRAG1)))))
SPECIALIZATIONS (VECTOR (VECTOR ONETYPE (VECTOR WE JUST ASK THE USER, NO DECISION TO MAKE)
AFFECTS
(VECTOR THE ASK:USER:ABOUT ALGORITHM)
RESULTS
(VECTOR PROGN (VECTOR PUPRIN1 "
PLEASE GIVE ME ")
(VECTOR PUPRINT ARG1)
(VECTOR SET ARG1 (VECTOR PREAD)))
ASK:USER:ABOUT)))
(PUTPROPS BETTER IDEN (((AND (EQUAL (CAR LI)
BETTER)
(EQUAL (LENGTH LI)
3))
(VECTOR BETTER (TRANSLATE (CADR LI)
T)
(TRANSLATE (CADDR LI)
T))))
BEING T
EXPLICIT:ARGS (B1 B2)
WHAT (TUPLE DECIDE WHICH OF (@ B1)
(@ B2)
IS MORE A PROPOS TO TRY)
HOW (TUPLE COMPARE THE WHEN PARTS OF (@ (CAR B1))
AND
(@ (CAR B2))
AND, IF NECESSARY, COMPARE THEIR COMPLEXITY VECTORS)
WHY (TUPLE PUP CAN ONLY TRY AT MOST ONE OF (@ (CAR B1))
AND
(@ (CAR B2))
AT A TIME)
META:CODE (PROGN (SETQ B1NEW B1)
(SETQ B2NEW B2)
(SETQ B1NEW (CONS (CAR B1NEW)
(MAPCAR (CDR B1NEW)
EVAL)))
(SETQ B2NEW (CONS (CAR B2NEW)
(MAPCAR (CDR B2NEW)
EVAL)))
(SETQ WHEN:DIFF (DIFFERENCE (WHEN:VALUE B1NEW)
(WHEN:VALUE B2NEW)))
(COND ((EQP WHEN:DIFF 0)
(SETQ RESULT1 (A:BEING:ORDER (CAR B1NEW)
(CAR B2NEW)))
(SETQ BECAUSE (APPEND BECAUSE (TUPLE THE WHEN PARTS OF (@ (CAR B1NEW))
AND
(@ (CAR B2NEW))
ARE EQUAL AND THE FORMER IS
(@ (COND (RESULT1 (QUOTE LESS))
(T (QUOTE MORE))))
COMPLEX THAN THE LATTER BEING))))
(T (SETQ RESULT1 (NOT (MINUSP WHEN:DIFF)))
(SETQ BECAUSE (APPEND BECAUSE (TUPLE THE WHEN PART OF THE
(@ (CAR B1NEW))
IS
(@ (COND (RESULT1 SUPERIOR)
(T INFERIOR)))
TO THE WHEN PART OF
(@ (CAR B2NEW)))))))
RESULT1)
EXPLICIT:ARGS:CHECK (AND (EQUAL T (GETP (CAR B1)
BEING))
(EQUAL T (GETP (CAR B2)
BEING)))
PREDICATE T
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR (VECTOR DICHOTOMY
(QUOTE (VECTOR (VECTOR WE USE A SIMPLE, FIXED TYPE OF COMPARING
FUNCTION TO MAINTAIN ORDERING)
(VECTOR WE USE A MORE COMPLEX TYPE OF COMPARING
FUNCTION)
(ERROR!)))
AFFECTS
(VECTOR THE BETTER ALGORITHM)
COMMENT
(COMMENT CHOICE #1 MEANS THAT WE CAN MERGE USING A SIMPLE, QUICK
FUNCTION SUCH AS CONS, NCONC1, ETC; CHOICE #2 INDICATES
THAT AN ACTUAL EVALUATION MUST BE DONE TO COMPARE TWO
ELEMENTS TO DECIDE WHICH COMES FIRST)
RESULTS
(VECTOR (VECTOR SIMPLE:COMPARE:FN)
(VECTOR COMPLEX:COMPARE:FN ARG1 ARG2))
BETTER)))
(PUTPROPS CHOOSE:FROM IDEN (((AND (EQUAL (CAR LI)
CHOOSE:FROM)
(EQUAL (LENGTH LI)
2))
(VECTOR CHOOSE:FROM (MAPCAR (CADR LI)
(FUNCTION (LAMBDA (Y)
(TRANSLATE Y T)))))))
BEING T
IMPLICIT:ARGS (EXP:TEST)
EXPLICIT:ARGS (S)
WHAT (TUPLE CHOOSE THE BEST BEING FROM THE SET (@ S)
OF BEINGS)
HOW (TUPLE COMPARE FEATURES OF THE ELEMENTS OF THE SET (@ S)
OF BEINGS)
WHY (TUPLE BECAUSE THE FLOW OF CONTROL OF A PROGRAM MUST BE DETERMINATE)
META:CODE (PROG (BEST)
(SETQ BEST (CAR S))
(SETQ BECAUSE (VECTOR WE MUST SELECT THE BEST BEING FROM
(INVECTOR (MAPCAR S (QUOTE CAR)))))
(COND ((SINGLETON S)
(SETQ BECAUSE (APPEND BECAUSE (VECTOR AND, TRIVIALLY,
(INVECTOR (CAR S))
IS OUR ONLY CHOICE))))
(T (MAPC (CDR S)
(FUNCTION (LAMBDA (S1)
(COND ((EQUAL T (BETTER S1 BEST))
(SETQ BEST S1))))))))
(SETQ BECAUSE (VECTOR NOW THAT WE HAVE SELECTED (CAR BEST)
AS THE BEST BEING OUT OF THE SET (MAPCAR S (QUOTE CAR))
WE MUST CARRY OUT (INVECTOR BEST)))
(COND ((SETQ TEMPBB (EVAL BEST))
(SETQ UNKNOWN:TASK TEMPBB))
((CDR S)
(CHOOSE:FROM (PULLOUT BEST S)))))
EXPLICIT:ARGS:CHECK (PROGN (SETQ EXP:TEST T)
(MAPC S (FUNCTION (LAMBDA (S1)
(COND ((NOT (EQUAL T (GETP (CAR S1)
BEING)))
(SETQ EXP:TEST NIL))))))
(COND (EXP:TEST)
(T (PUPRIN1 (VECTOR WARNING, WARNING; NOT ALL OF
(MAPCAR S (QUOTE CAR))
ARE BEINGS)))))
COMPLEXITY:VECTOR (.2 .4 .6 .5 .1))
(PUTPROPS CLARIFY:IMPROBABLE:SITUATION BEING T
IMPLICIT:ARGS (WHAT:WE:DID RESPONSE GD1 GD2)
EXPLICIT:ARGS (U)
EXPLICIT:ARGS:CHECK (COND ((SOME CODING:WARNING:LIST (FUNCTION
(LAMBDA (CWL)
(LESSP (IMPROBABILITY:COMPLEX
CWL)
500)))))
((NULL (CDR CODING:WARNING:LIST)))
(T (SETQ CODING:WARNING:LIST
(MAPCAR CODING:WARNING:LIST
(FUNCTION
(LAMBDA
(COWL)
(CONS (TIMES .9 (
IMPROBABILITY:COMPLEX
COWL))
(CDR COWL))))))
NIL))
WHAT (TUPLE RESOLVE DOUBTS ABOUT A STRANGE AND PROBABLY INCORRECT DETAIL OF
CODE)
HOW (TUPLE IF THE STRANGE PIECE OF CODE IS WRONG, CORRECT IT)
WHY (TUPLE WRONG CODE GIVES WRONG RESULTS; SUCH POOR PERFORMANCE EVENTUALLY
WOULD CAUSE MY DEATH)
WHEN ((CODING:WARNING:LIST 51
(TUPLE BECAUSE THERE IS A KNOWN LIST OF STRANGE
DETAILS, NAMELY (@ CODING:WARNING:LIST)))
(UNDEFINED:SECTION:LIST -40
(TUPLE BECAUSE WE MAY VERY EASILY RESOLVE THE
STRANGENESSES IN THE PROCESS OF DEFINING
THE UNKNOWN FUNCTIONS, SO WE SHOULD DO
THE LATTER FIRST))
(EXECUTABLE:INFO:LIST -200
(TUPLE BECAUSE THERE IS SOMETHING IMMEDIATELY
DO-ABLE, SO WE SHOULD DO IT; IT MAY RESOLVE
SOME STRANGENESSES)))
COMMENTS ((SETQ WHOLE:CHOICE (TRUE:MINIMUM CODING:WARNING:LIST
IMPROBABILITY:COMPLEX))
(SETQ CHOICE (CDR WHOLE:CHOICE))
(SETQ DOING:PUP:LIST (CONS (VECTOR IMPROBABILITY (INVECTOR CHOICE))
DOING:PUP:LIST)))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR PUP WORKED ON SOMETHING
IMPROBABLE, NAMELY (INVECTOR
CHOICE)
,AND HERE IS WHAT WE FINALLY DID
ABOUT IT: (INTUPLE WHAT:WE:DID))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
META:CODE (SETQ
WHAT:WE:DID
(COND
((MATCH (VECTOR IN ALL CODE GENERATED, ANY1 SHOULD BE REPLACED
BY ANY2)
CHOICE)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(MAPC ASSERT:LISTS (FUNCTION (LAMBDA
(AL)
(SET AL (DSUBST ANY2 ANY1
(EVAL AL))))))
(MAPC
(SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION
(LAMBDA
(B)
(AND (EQUAL (CAR ANY2)
(QUOTE APPEND))
(NOT (LISTP ANY1))
(EQUAL (CAR (SETQ B:META:CODE (GETP B META:CODE)))
STRUCTURE)
(MEMBER ANY1 (FLATTEN B:META:CODE))
(PUT B META:CODE
(MAPCONC B:META:CODE
(FUNCTION
(LAMBDA
(PIECE:OF:CODE)
(COND
((NOT (EQUAL ANY1 (CADDR
PIECE:OF:CODE)))
(LIST PIECE:OF:CODE))
((MAPCAR (CDR ANY2)
(FUNCTION
(LAMBDA (
SUBPIECE:OF:CODE)
(SUBST
SUBPIECE:OF:CODE
ANY1
PIECE:OF:CODE)))))
))))))
(MAPC SET:OF:BEING:PARTS
(FUNCTION (LAMBDA (P)
(COND
((GETP B P)
(PUT B P (DSUBST ANY2 ANY1
(GETP B P)))))
))))))
(VECTOR WE REPLACED ALL OCCURRENCES OF (INVECTOR ANY1)
BY
(INVECTOR ANY2)))
((OR (MATCH (VECTOR COMMENT ANY1 IN ANY2 UNDEFINED; WILL BE
GOTTEN LATER; PROBABLY FRAG1 SINCE ANY3)
CHOICE)
(MATCH (VECTOR COMMENT WARNING ANY1 IN ANY2 UNDEFINED; WILL
BE GOTTEN LATER; PROBABLY FRAG1 SINCE ANY3)
CHOICE))
(COND
((NUMBERP (CAR (LAST (COLON:BREAK ANY2))))
(SETQ H1 ANY1)
(SETQ H2 ANY2)
(SETQ H3 FRAG1)
(PUPRIN1
(CONCAT
"
PUP: WHILE LOOKING OVER SOME POSSIBLE ERRORS IN THE CODE SO FAR,
I NOTICE THAT WE HAVE LEFT " H1 " UNDEFINED. IT IS LOCATED IN
THE FUNCTION " H2 ". IN OTHER WORDS, AT THE INSTANT WE KNOW
THAT " ANY3 "
I SUSPECT THAT THE ANSWER IS " H3
".
PLEASE TYPE IN ONE OF THESE, OR ELSE YOUR OWN ANSWER, OR ELSE THE
SINGLE WORD 'DEFER' -- WHICH MEANS 'I AM UNSURE, SO COME BACK TO THIS
LATER.' GO AHEAD NOW
USER: "))
(SETQ RESPONSE (PREAD))
(COND
((EQUAL RESPONSE (QUOTE DEFER))
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(SETQ CODING:WARNING:LIST
(NCONC1 CODING:WARNING:LIST
(CONS (TIMES 3 (IMPROBABILITY:COMPLEX
WHOLE:CHOICE))
CHOICE)))
(VECTOR NOTHING))
((EQUAL H2 GLOBAL:CONTEXT:0)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(SETQ GLOBAL:INITIALIZATION:LIST
(CONS (LIST (QUOTE SETQ)
(SETQ IXS
(COND ((MATCH (TUPLE INITIAL
VALUE OF
FRAG1)
(COLON:BREAK H1))
(COLON:BACK FRAG1))
(T H1)))
RESPONSE)
GLOBAL:INITIALIZATION:LIST))
(VECTOR (@ IXS)
WILL RECEIVE THE GLOBAL INITIALIZATION VALUE
(@ RESPONSE)))
((MEMBER RESPONSE H3)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(MAPC SET:OF:BEING:PARTS
(FUNCTION (LAMBDA (P)
(COND
((GETP H2 P)
(PUT H2 P (DSUBST
RESPONSE H1
(GETP H2 P))))))))
(SETQ ARG:LIST (GETP H2 EXPLICIT:ARGS))
(VECTOR WE SUBSTITUTED (@ RESPONSE)
FOR
(@ H1)
THROUGHOUT THE FUNCTION (@ H2)
.BY THE WAY, THIS WAS ONE OF MY SUGGESTIONS!! THE
META:CODE WAS CHANGED FROM (INVECTOR
(GETP H2 META:CODE))
TO
(INVECTOR (PUT H2 META:CODE
(GETCODE (OUTVECTOR (GETP H2
META:CODE))
H2 1)))))
(T (SETQ RESPONSE (OUTVECTOR (TRANSLATE (INVECTOR RESPONSE)
T)))
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(COND ((EQUAL (LENGTH RESPONSE)
1)
(SETQ RESPONSE (CAR RESPONSE))))
(MAPC SET:OF:BEING:PARTS
(FUNCTION (LAMBDA (P)
(COND
((GETP H2 P)
(PUT H2 P
(DSUBST RESPONSE H1
(GETP H2 P))))))
))
(SETQ ARG:LIST (GETP H2 EXPLICIT:ARGS))
(VECTOR WE SUBSTITUTED (INVECTOR RESPONSE)
FOR
(INVECTOR H1)
THROUGHOUT THE FUNCTION (@ H2)
.THIS WASN'T WHAT I EXPECTED, BY THE WAY. THE
META:CODE WAS CHANGED FROM (INVECTOR
(GETP H2 META:CODE))
TO
(INVECTOR (PUT H2 META:CODE
(GETCODE (OUTVECTOR
(GETP H2 META:CODE))
H2 1)))))))
(T (SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(VECTOR DUE TO THE CHARACTER OF (@ ANY2)
,I ASSUME THAT I AM NOT REALLY SUPPOSED TO WORRY
ABOUT THIS EVER.))))
((MATCH (VECTOR ANY1 IS A DATA STRUCTURE, WITH ELEMENTS OF TYPE
ANY2 ;BUT NO ACCESSION INFORMATION IS KNOWN)
CHOICE)
(SETQ H1 ANY1)
(SETQ H2 ANY2)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(COND ((SATISFY (VECTOR IS STRUCTURE (LIST VECTOR H1 H2)))
(VECTOR ACCESSION ROUTINES NOW EXIST FOR THE DATA
STRUCTURE (@ H1)
;NAMELY,
(GETP H1 DATA:STRUCTURE)))
(T (SETQ CODING:WARNING:LIST
(NCONC1 CODING:WARNING:LIST
(CONS (TIMES 3 (CAR WHOLE:CHOICE))
CHOICE)))
(VECTOR WE UNSUCCESSFULLY TRIED TO DEVELOP ROUTINES
FOR ACCESSION TO THE VAGUE DATA STRUCTURE
(@ H1)))))
((MATCH (VECTOR WARNING WE HAVE FOUND NO ANY1 INTO ANY2 DATA
STRUCTURE)
CHOICE)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(SETQ GD1 ANY1)
(SETQ GD2 ANY2)
(COND ((SATISFY (VECTOR SOME (@ GD1)
(@ GD2)))
(VECTOR THERE ARE (@ GD1)
ASSOCIATED WITH THE DATA STRUCTURE (@ GD2)))
(T (SETQ CODING:WARNING:LIST
(NCONC1 CODING:WARNING:LIST
(CONS (TIMES 3 (CAR WHOLE:CHOICE))
CHOICE)))
(VECTOR WE TRIED UNSUCCESSFULLY TO WORRY ABOUT THE
FACT THAT THERE AREN'T ANY OBVIOUS
(@ GD1)
W.R.T THE DATA STRUCTURE (@ GD2)))))
((MATCH (VECTOR DELETE ALL MENTION OF ANY1 FROM ALL CODE
GENERATED)
CHOICE)
(SETQ ANY1:COPY ANY1)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(MAPC ASSERT:LISTS
(FUNCTION (LAMBDA
(AL)
(SET AL (MAPCONC AL
(FUNCTION
(LAMBDA
(PAL)
(COND
((MEMBER ANY1:COPY
(FLATTEN
PAL))
NIL)
(T (LIST PAL))))))))))
(MAPC (SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION (LAMBDA (B)
(COND
((LISTP (GETP B META:CODE))
(PUT B META:CODE
(CAR (OUTFORM ANY1:COPY
(GETP B META:CODE)
))))))))
(VECTOR WE DELETED ALL MENTION OF (@ ANY1:COPY)
FROM ALL THE BEINGS CODES))
((MATCH (VECTOR INFINITE LOOP IN ANY1 FROM ANY2 TO ANY3)
CHOICE)
(SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(VECTOR INFINITE LOOP TERMINATION DECISION SHOULD BE MADE AT
THIS POINT, BUT ISNT IN YET))
(T (SETQ CODING:WARNING:LIST (PULLOUT WHOLE:CHOICE
CODING:WARNING:LIST))
(SETQ CODING:WARNING:LIST (NCONC1 CODING:WARNING:LIST
(CONS (TIMES 3
(
IMPROBABILITY:COMPLEX WHOLE:CHOICE))
CHOICE)))
(VECTOR NOTHING, SINCE I COULDNT UNDERSTAND IT)))))
(PUTPROPS CLASSIFICATORY:CONCEPT:FORMATION BEING T
WHAT (TUPLE LEARN HOW TO DISTINGUISH NONHIERARCHICAL CLASSES)
HOW (TUPLE BY CONSTRUCTING A PARTITION OF THE DOMAIN OF STIMULI)
META:CODE (PROGN (PARTITION:A:DOMAIN))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS COMPARE BEING T
EXPLICIT:ARGS (POSSIBLE:OBJECT IDEAL:OBJECT)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE COMPARE (@ POSSIBLE:OBJECT)
WITH
(@ IDEAL:OBJECT))
HOW (TUPLE BY APPLYING A FUNCTION (TUPLE PROBABLY ALREADY KNOWN)
TO EITHER THESE TWO OBJECTS, OR ELSE TO THEIR CORRESPONDING PARTS.)
WHY (TUPLE PUP WANTS TO SEE IF (@ POSSIBLE:OBJECT)
IS CLOSE ENOUGH TO (@ IDEAL:OBJECT))
META:CODE (COMMENT DEPENDS UPON THE PARTICULAR FLAVOR OF COMPARISON)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE TEST)
SPECIALIZATIONS (VECTOR
(VECTOR
DICHOTOMY
(TUPLE PROGN (VECTOR COMPARING MAY INVOLVE A FUNCTION APPLIED DIRECTLY TO THE
TWO ARGUMENTS)
(VECTOR COMPARING MAY INVOLVE APPLYING A FUNCTION TO CORRESPONDING PAIRS
OF SUBPARTS OF THE OBJECTS, AND FINALLY JOINING TOGETHER ALL
THESE SUB-COMPARISONS' RESULTS)
(QUOTE (PROGN (DETERMINE:ARG:VALUE CHOICE)
(DETERMINE:ARG2:VALUE CHOICE)
(SETQ H1 (HIGHLY:STRUCTURED ARG1))
(SETQ H2 (HIGHLY:STRUCTURED ARG2))
(SETQ C12 (STRUCTURE:COMPATIBLE ARG1 ARG2))
(COND ((AND H1 H2 C12)
NIL)
((AND H1 H2)
(ERROR))
((OR H1 H2)
NIL)
(T T)))))
AFFECTS
(VECTOR THE COMPARE ALGORITHM)
RESULTS
(VECTOR
(QUOTE (COND ((SETQ SA (CADR (SETQ SC (SASSOC (CADR CHOICE)
LOOP:TERMINATION:LIST))))
(COND ((MEMBER SA PRIMITIVE:VARS:LIST)
(VECTOR PROGN ARG1 ARG2
(COMMENT THE PRESENCE OF ARG1 AND ARG2 ABOVE
DOES NO HARM; IT IS NECESSARY SOMEWHERE
IN THE FUNCTION SO THAT PUP WILL INSERT
COMMENTS ABOUT WHAT ARG1 AND ARG2 GET
INSTANTIATED AS.)
(COMMENT SINCE THIS COMPARISON PREDICATE MUST
ALWAYS RETURN THE CONSTANT VALUE
(@ SA)
,ALL THAT (CADR CHOICE)
CAN POSSIBLY BE IS A SEQUENCE OF
ASSIGNMENTS, REWRITES, AND ITERATIVE
STATEMENTS, ENDING WITH (@ SA))
(@ SA)))
(T (SETQ SB (CADR SA))
(VECTOR PROGN
(COMMENT HERE WE MAY LATER WANT TO PUT SOME
ASSIGNMENTS, REWRITES, AND ITERATIVE
STATEMENTS)
(VECTOR COND (VECTOR (VECTOR NOT (INVECTOR
SB))
(CADDR SC))
(INVECTOR (CADDDR SC)))))))
(T (VECTOR JOINING:FUNCTION ARG1 ARG2))))
(QUOTE
(VECTOR PROGN ARG1 ARG2
(COMMENT ARG1 AND ARG2 ARE HERE SIMPLY TO CAUSE PUP TO STICK IN
COMMENTS ABOUT THEIR INSTANTIATION)
(APPEND (VECTOR JOINING:FUNCTION)
(COND
((HIGHLY:STRUCTURED ARG1)
(MAPCAR (CDR (GETP ARG1 META:CODE))
(FUNCTION
(LAMBDA
(PARTICLE HOLD:ANY1 SECOND:OBJ)
(SETQ HOLD:ANY1 (CAR PARTICLE))
(MAPC TYPE:OF:LIST
(FUNCTION
(LAMBDA
(TOL)
(COND ((MATCH (VECTOR
ANY1 TYPE OF
(CONS VECTOR
PARTICLE)
FRAG1)
TOL)
(SETQ HOLD:ANY1 ANY1))))))
(SETQ SECOND:OBJ (SUBST ARG2
(CAR (COLON:BREAK
ARG1))
(COPY (COLON:BREAK
HOLD:ANY1))))
(SETQ SECOND:OBJ
(COND
((MEMBER ARG2 SECOND:OBJ)
SECOND:OBJ)
(T (APPEND SECOND:OBJ
(LIST (QUOTE OF)
ARG2)))))
(COND ((NUMBERP (CAR (LAST SECOND:OBJ)))
(SETQ
SECOND:OBJ
(REVERSE
(CONS (SETQ NEW:F:NUMBER
(ADD1 NEW:F:NUMBER))
(CDR (REVERSE SECOND:OBJ))))
)))
(SETQ SECOND:OBJ (COLON:BACK SECOND:OBJ))
(LIST VECTOR COMPARE HOLD:ANY1 SECOND:OBJ))))
)
((HIGHLY:STRUCTURED ARG2)
(SETQ SSTRUC (STRUCTURE))
(SETQ TSTRUC (STRUCTURE))
(SETQ
FRESULT
(MAPCAR (CDR (GETP ARG2 META:CODE))
(FUNCTION
(LAMBDA
(PARTICLE HOLD:ANY1 FIRST:OBJ)
(SETQ HOLD:ANY1 (CAR PARTICLE))
(MAPC TYPE:OF:LIST
(FUNCTION
(LAMBDA
(TOL)
(COND
((MATCH (VECTOR ANY1 TYPE OF
(CONS VECTOR
PARTICLE)
FRAG1)
TOL)
(SETQ HOLD:ANY1 ANY1))))))
(SETQ FIRST:OBJ
(SUBST ARG1 (CAR (COLON:BREAK ARG2))
(COPY (COLON:BREAK HOLD:ANY1))
))
(COND
((NUMBERP (CAR (LAST FIRST:OBJ)))
(SETQ
FIRST:OBJ
(REVERSE (CONS (SETQ NEW:F:NUMBER
(ADD1
NEW:F:NUMBER))
(CDR (REVERSE
FIRST:OBJ)))))
))
(SETQ FIRST:OBJ
(COND
((MEMBER ARG1 FIRST:OBJ)
FIRST:OBJ)
(T (APPEND FIRST:OBJ
(LIST (QUOTE OF)
ARG1)))))
(SETQ FIRST:OBJ (COLON:BACK FIRST:OBJ))
(SETQ TSTRUC
(NCONC1 TSTRUC
(APPEND (LIST (CAR PARTICLE)
(CADR PARTICLE)
FIRST:OBJ)
(CDDDR PARTICLE))))
(SETQ SSTRUC
(NCONC1 SSTRUC
(APPEND (LIST (CAR PARTICLE)
(CADR PARTICLE)
HOLD:ANY1)
(CDDDR PARTICLE))))
(LIST VECTOR COMPARE FIRST:OBJ HOLD:ANY1)))
))
(PUT ARG2 META:CODE SSTRUC)
(COND ((GETP ARG1 BEING)
(PUT ARG1 META:CODE TSTRUC))
(T (SET ARG1 ARG1)
(SETQ CODE TSTRUC)
(SETQ BNAME ARG2)
(SETQ FNAME ARG1)
(SATISFY (VECTOR IS BEING FNAME))))
FRESULT))))))
COMPARE)
(VECTOR ALTERNATIVES (VECTOR NOMINAL:RESULT ORDINAL:RESULT RATIO:RESULT
VECTOR:RESULT)
AFFECTS
(VECTOR THE TERMINATION CHARACTERISITCS OF THE COMPARING)
WHEN
(VECTOR BEFORE THE COMPARING ROUTINE IS FINALIZED)
COMPARE))
PREDICATE T)
(PUTPROPS COMPARITIVE:CONCEPT:FORMATION BEING T
WHAT (TUPLE LEARN TO DISTINGUISH AND RANK NONHIERARCHICAL CLASSES)
HOW (TUPLE BY CONSTRUCTING A PARTITION AND AN ORDERING OF THE RESULTANT
SUBSETS OF STIMULI)
META:CODE (PROGN (PARTITION:A:DOMAIN)
(ORDER PARTITION))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS COMPLEX:ALTERATION BEING T
EXPLICIT:ARGS (S)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE ALTER (@ S)
AND/OR ANOTHER ELEMENT OF THE SAME OUTER LIST)
HOW (TUPLE BY MODIFYING THE STRUCTURE OF SUCH AN ELEMENT)
WHY (TUPLE BECAUSE MODIFYING THE STRUCTURE OF AN INDIVIDUAL ELEMENT IS EQUIVALENT TO
UPDATING OUR DESCRIPTION OF A SINGLE PARTICULAR CONCEPT, AND THIS IS
FUNDAMENTAL TO A DECENT CONCEPT FORMATION PROGRAM)
META:CODE (VECTOR DEPENDS ON WHAT THE USER WANTS DONE)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR
(VECTOR
ONETYPE
(VECTOR WE PUT IN A 'MODIFY:STRUCTURE' CALL FOR EACH SUBPART OF
ARG1, SO NO DECISION NEED BE MADE HERE: THE MODIFY:STRUCTURE
BEINGS ALWAYS MAKE A DECISION THEMSELVES)
AFFECTS
(VECTOR THE COMPLEX:ALTERATION ALGORITHM)
RESULTS
(APPEND
(VECTOR PROGN)
(MAPCONC
(PROGN (SETQ PS
(COND ((MATCH (TUPLE P O S S I B L E : FRAG1)
(UNPACK (DETERMINE:ARG:VALUE CHOICE)))
ARG1)
(T (PACK (LIST (QUOTE POSSIBLE:)
ARG1)))))
(SETQ SPS (PACK (LIST (QUOTE SET:OF:)
(PLURAL PS))))
(COND
((AND (MEMBER PS IS:STRUCTURE:LIST)
(NOT (MEMBER ARG1 IS:STRUCTURE:LIST)))
(COND ((NULL (GETP ARG1 BEING))
(SETQ BNAME PS)
(SETQ FNAME ARG1)
(SETQ CODE (GETP PS META:CODE))
(SATISFY (VECTOR IS BEING FNAME))))
(PUT ARG1 DATA:STRUCTURE (SUBST ARG1 PS
(COPY (GETP PS
DATA:STRUCTURE))))
(MAPC CODING:WARNING:LIST
(FUNCTION
(LAMBDA
(CW)
(COND ((AND (MATCH (TUPLE ANY1 VECTOR
COMMENT ANY2 IN
(@ PS)
UNDEFINED; WILL BE
GOTTEN LATER;
FRAG1)
CW)
(MEMBER ANY2
(FLATTEN (GETP ARG1
DATA:STRUCTURE))))
(SETQ
CODING:WARNING:LIST
(CONS (SUBPAIR (LIST PS ANY1)
(LIST ARG1
(SUB1 ANY1))
(COPY CW)
T)
CODING:WARNING:LIST)))))))
(MAPC (MAPCAR (CDR (GETP PS META:CODE))
(QUOTE CADDR))
(FUNCTION
(LAMBDA (PROP)
(COND
((GETP PROP BEING)
(PUT PROP DATA:STRUCTURE
(APPEND (GETP PROP
DATA:STRUCTURE)
(LIST (QUOTE ALTERNATE)
ARG1 PS))))))))
(SETQ IS:STRUCTURE:LIST (CONS ARG1 IS:STRUCTURE:LIST)))
)
(SATISFY IS STRUCTURE (LIST VECTOR SPS PS))
(CDR (GETP ARG1 META:CODE)))
(FUNCTION
(LAMBDA
(PARTICLE)
(PUPRIN1
(CONCAT
"
WE MIGHT WANT TO MODIFY HERE THE SUBPART " PARTICLE " OF THE ELEMENT " ARG1 " OF THE DATA STRUCTURE " SPS
"? PLEASE ANSWER YES OR NO, NOTICING
THAT 'YES' ALSO ENCOMPASSES 'MAYBE' IN THIS CASE.
USER: "))
(COND
((EQUAL (PREAD)
(QUOTE NO))
(PUPRIN1
"
OK, SO WE DON'T PUT IN ANY CORRESPONDING FUNCTION CALL HERE
")
NIL)
(T
(PUPRIN1
"
SO WE DO PUT IN THE CORRESPONDING FUNCTION CALL HERE.
")
(LIST (VECTOR MODIFY:STRUCTURE (CADDR PARTICLE)
(LIST (QUOTE QUOTE)
ARG1))))))))
(COND ((AND (NOT (EQUAL ARG1 PS))
(FLOW:PRECEDED (VECTOR SET (@ PS)
FRAG1))
(PUPRIN1 (CONCAT "
SHOULD I ALTER BOTH " ARG1 " AND " PS " AT THIS POINT?
USER: "))
(MEMBER (PREAD)
(TUPLE Y T YES MAYBE)))
(LIST (VECTOR COMPLEX:ALTERATION (@ PS))))))
COMPLEX:ALTERATION)))
(PUTPROPS COMPLEX:COMPARE:FN BEING T
EXPLICIT:ARGS:CHECK T
PREDICATE T)
(PUTPROPS CONCEPT:FORMATION BEING T
IDEN (((MEMBER LI (QUOTE ((CONCEPT FORMATION)
(CONCEPT:FORMATION)
(CONCEPT LEARNING)
(FORM CONCEPTS)
(LEARN CONCEPTS)
(LEARNS CONCEPTS)
(FORMS CONCEPTS))))
(VECTOR CONCEPT:FORMATION)))
WHAT (TUPLE LEARN HOW TO IMPOSE A CONCEPT STRUCTURING UPON A DOMAIN; LEARN HOW TO
CHARACTERIZE, OR AT LEAST DISTINGUISH, VARIOUS CONCEPTS)
HOW (TUPLE BY CHOOSING THE DESIRED TYPE OF CONCEPT FORMATION CALLED FOR, AND THEN
CARRYING IT OUT)
WHY (TUPLE CONCEPT:LEARNING IS NECESSARY TO CONCEPT KNOWLEDGE)
WHEN (((MEMBER TYPE:OF:C:F ABLE:PUP:LIST)
-70
(TUPLE BECAUSE IF WE CAN ALREADY DO (@ TYPE:OF:C:F)
THEN WE SHOULDNT TRY TO DO IT OVER AGAIN))
((MEMBER (QUOTE (CHARACTERIZE CLASSES))
PUP:WANTS:LIST)
88
(QUOTE (BECAUSE CONCEPT FORMATION IS A GOOD WAY TO GET A CHARACTERIZATION OF
CLASSES)))
(T (COND (NEW:INFO:LIST -60)
(T 40))
(QUOTE (BECAUSE NEW INFORMATION MIGHT ALTER OUR COURSE OF ACTION))))
META:CODE (EVAL (LIST TYPE:OF:C:F))
PRE:REQUISITES ((VECTOR AWARE USER (VECTOR PUP IS ABOUT TO WORK ON CONCEPT FORMATION))
(VECTOR TYPE OF CONCEPT:FORMATION IS TYPE:OF:C:F)
(VECTOR AWARE USER
(VECTOR THE TYPE OF CONCEPT FORMATION PUP IS ABOUT TO WORK ON IS
(@ TYPE:OF:C:F))))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR PUP HAS THOUGHT ABOUT THE (@ TYPE:OF:C:F)
TYPE OF CONCEPT:FORMATION)))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE INFERENCE:DEMONS ATTENTION:DEMONS)
MAIN:EFFECTS (((VECTOR ABLE PUP (VECTOR LEARN CONCEPTS))
(VECTOR CONCEPT:FORMATION)))
AFFECTS (TUPLE (TUPLE (EVAL TYPE:OF:C:F)
CALLED))
COMPLEXITY:VECTOR (.1 .5 .5 .5 .1)
GENERALIZATIONS (ATTEND LEARN INDUCTIVE:INFERENCE)
SPECIALIZATIONS (VECTOR (VECTOR ALTERNATIVES (VECTOR CLASSIFICATORY:CONCEPT:FORMATION
COMPARITIVE:CONCEPT:FORMATION
METRICAL:CONCEPT:FORMATION)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR BOOLEAN (VECTOR CONCEPTS MAY VARY WITH TIME)
AFFECTS
(VECTOR THE BASIC STRUCTURE OF FORMING A CONCEPT)
CONCEPT:FORMATION)
(VECTOR BOOLEAN
(VECTOR CONCEPT FORMATION MAY DEPEND UPON THE SPEED OF
PRESENTATION OF THE STIMULI)
AFFECTS
(VECTOR THE AMOUNT OF EFFORT (@ TASK:NAME)
SHOULD SPEND ON IDENTIFYING EACH STIMULUS)
CONCEPT:FORMATION)
(VECTOR DICHOTOMY
(VECTOR (VECTOR INSTANCES MAY BE LEFT IN VIEW
INDEFINITELY)
(VECTOR INSTANCES MAY BE REMOVED AFTER PROCESSING)
)
RESULTS
(VECTOR (VECTOR NEW RELATIONS CAN BE DERIVED AS NEEDED)
(VECTOR ALL RELATIONS MUST BE DERIVED UPON
INITIAL EXPOSURE TO THE STIMULUS))
WHEN
(VECTOR BEFORE DECIDING FIRMLY HOW TO GET RELATIONS FROM
INPUT STIMULI)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES (VECTOR CONJUNCTIVE:CONCEPT:FORMATION
DISJUNCTIVE:CONCEPT:FORMATION
MIXED:CONJUNCTIVE:AND:DISJUNCTIVE:CONCEPT:FORMATION)
AFFECTS
(VECTOR HOW (@ TASK:NAME)
STORES THE DESCRIPTION OF A CONCEPT)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES (VECTOR POSITIVE:TRANSFER:CONCEPT:FORMATION
NEGATIVE:TRANSFER:CONCEPT:FORMATION
NO:TRANSFER:CONCEPT:FORMATION
POSITIVE:AND:NEGATIVE:TRANSFER:CONCEPT:FORMATION)
AFFECTS
(VECTOR HOW PREVIOUSLY:LEARNED CONCEPTS AND
PREVIOUSLY:ENCOUNTERED STIMULI AFFECT THE
LEARNING OF NEW CONCEPTS AND THE RECOGNITION THAT
A NEW CONCEPT IS NEW)
WHEN
(VECTOR BEFORE DECIDING FIRMLY HOW TO SEARCH THROUGH THE
SET OF CONCEPTS)
CONCEPT:FORMATION)
(VECTOR ALTERNATIVES (VECTOR POSITIVE:INSTANCE:UTILIZATION
NEGATIVE:INSTANCE:UTILIZATION
POSITIVE:AND:NEGATIVE:INSTANCE:UTILIZATION)
AFFECTS
(VECTOR WHAT INFORMATION (@ TASK:NAME)
MAY USE TO MODIFY THE DESCRIPTION OF A CONCEPT)
PARTS
(VECTOR META:CODE)
CONCEPT:FORMATION)
(VECTOR BOOLEAN (VECTOR SUBJECT:SPECIFIC BEHAVIOR MAY BE REQUIRED
OF (@ TASK:NAME))
AFFECTS
(VECTOR WHETHER PARAMETERS DESCRIBING AN INDIVIDUAL MUST
BE PREAD IN BY (@ TASK:NAME))
WHEN
(VECTOR BEFORE ANY ROUTINES ARE FINALIZED)
WHY
(VECTOR BECAUSE ANY PROCESSING ROUTINE MAY HAVE TO DEPEND
UPON SOME INDIVIDUAL PARAMETERS)
CONCEPT:FORMATION)
(VECTOR ADAPTATION (VECTOR DESIRED DIALOGUE BETWEEN (@ TASK:NAME)
AND ITS USERS)
AFFECTS
(VECTOR OUTPUT DETAILS)
CONCEPT:FORMATION))
ALTERNATIVES ((GRAMMATICAL:INFERENCE PATTERN:RECOGNITION SIMULATED:EVOLUTION)))
(PUTPROPS CONDITIONAL:DELETION EXPLICIT:ARGS (E)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE PERHAPS WE WILL STICK IN A CONDITIONAL DELETION STATEMENT, STICKING IN AN
(@ E)
-TYPE ELEMENT INTO ITS PARENT STRUCTURE)
HOW (TUPLE WE WILL ASK THE USER, PROBABLY)
WHY (TUPLE BECAUSE IF AN DELETION IS NOT TO BE MADE, THEN WE WANT TO WIPE OUT ALL
TRACES OF THIS STATEMENT; IF ONE IS TO BE MADE, WE WILL NEED THE USER TO
GUIDE US SINCE THE DETAILS HERE DEPEND CRITICALLY UPON THE DETAILS HE HAS
IN MIND FOR THE PROGRAM)
META:CODE (VECTOR WE ASK THE USER)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE MODIFY:STRUCTURE)
SPECIALIZATIONS (VECTOR
(VECTOR
BOOLEAN
(VECTOR DO I, AT THIS POINT, CONDITIONALLY DELETE
(PROGN (SETQ PS
(COND ((MATCH (TUPLE P O S S I B L E : FRAG1)
(UNPACK ARG1))
ARG1)
(T (PACK (LIST (QUOTE POSSIBLE:)
ARG1)))))
(SETQ SPS (PACK (LIST (QUOTE SET:OF:)
(PLURAL PS))))
(SET SPS SPS)
(SET ARG1 ARG1)
(SET PS PS)
(SATISFY (VECTOR IS STRUCTURE
(LIST VECTOR SPS PS)))
(COND ((AND (MEMBER ARG1 IS:STRUCTURE:LIST)
(NOT (MEMBER (LIST VECTOR SPS PS)
IS:STRUCTURE:LIST)))
(SETQ PS (VECTOR I:DONT:KNOW:WHAT))
(SETQ SPS ARG1)
(SETQ ARG1 (COLON:BACK (CDDR (COLON:BREAK
ARG1)))))
(T ARG1)))
,OR A SIMILAR ELEMENT, INTO THE DATA STRUCTURE
(@ SPS)
??? PLEASE RESPOND YES OR NO; IF YOU SAY 'YES', THEN I
WILL PROBABLY HAVE TO ASK YOU SOME MORE QUESTIONS.)
AFFECTS
(VECTOR THE CONDITIONAL:DELETION ALGORITHM)
NO:RESULTS
(QUOTE ((SETQ CODING:WARNING:LIST
(CONS (TUPLE 10 VECTOR DELETE ALL MENTION OF
(CADR CHOICE)
FROM ALL CODE GENERATED)
CODING:WARNING:LIST))))
BOTH:RESULTS
(QUOTE ((VECTOR NOTHING IN COMMON)))
YES:RESULTS
(QUOTE
((PUPRIN1
"
NOW WE MUST KNOW 2 THINGS:
(1) WHAT WE DELETE
(2) UNDER WHAT CONDITION WE DO THE DELETION
NOTES ABOUT (1): IF WE ARE DELETING AN ALREADY EXISTING THING, THEN
JUST GIVEITS NAME; IF IT IS NEW, GIVE AN EXPRESSION INDICATING HOW WE
GET IT, PERHAPS IN TERMS OF ARG1.
")
(PUPRINT (TUPLE RECALL THAT HERE, ARG1 IS INSTANTIATED AS
(@ ARG1)))
(PUPRIN1
"
NOTES ABOUT (2): YOU MAY REFER TO THE RESULT OF (1) AS ")
(PUPRIN1 (SETQ RS (PACK (TUPLE RESULT: (SETQ RESULT:COUNTER
(ADD1
RESULT:COUNTER)))))
)
(PUPRIN1
", IF (1) IS
NOT SIMPLY AN OLD NAME.
ALSO, WE ASSUME THAT PART OF THE CONDITION (2) IS THE FACT THAT ")
(PUPRINT RS)
(PUPRIN1
" IS NATURALLY ALREADY IN THE LIST. THIS NEED NOT BE RESTATED
BY THE USER.
USER: (1): ")
(SETQ RESULTANT (LIST:TRANSLATE (INVECTOR (PREAD))
T))
(PUPRIN1 "
USER: (2): ")
(SETQ CONDIT (LIST:TRANSLATE (INVECTOR (PREAD))
T))
(COND ((EQUAL (CADR RESULTANT)
(QUOTE AND))
(SETQ RESULTANT (APPEND (VECTOR LIST:JOIN)
(CDDR RESULTANT)))))
(SETQ HTAL (CADR (MEMBER (QUOTE ACCESS)
(GETP ARG1 DATA:STRUCTURE))))
(SETQ TAL (COND ((LISTP HTAL)
(CDR HTAL))))
(SETQ RESULTANT (SUBPAIR (MAPCAR TAL (FUNCTION
(LAMBDA (A)
(CAR (LAST A)))))
(MAPCAR TAL (FUNCTION (LAMBDA
(A2)
(CDADR A2))))
(COPY RESULTANT)
T))
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA
(TOL)
(MATCH (VECTOR (CADR CHOICE)
TYPE OF
(VECTOR
CONDITIONAL:DELETEION)
IS FRAG1 USED IN
ANY2)
TOL))))
(SETQ
TYPE:OF:LIST
(CONS
(VECTOR
(CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(VECTOR
PROGN
(VECTOR SETQ (@ RS)
(INVECTOR RESULTANT))
(VECTOR
COND
(VECTOR
(INVECTOR CONDIT)
(PROGN
(SETQ
TSUB
(SUBST
RS
(QUOTE X)
(CADDAR (OUTVECTOR
(CADR (MEMBER (QUOTE DELETE)
(GETP SPS
DATA:STRUCTURE)))))
))
(COND
((AND (DETERMINE:ARG2:VALUE CHOICE)
(EQUAL (EVAL ARG2)
(SETQ TS2
(CADR (MEMBER (QUOTE
ALTERNATE)
(GETP SPS
DATA:STRUCTURE)))))
)
(SUBST TS2 (CADDR (MEMBER (QUOTE ALTERNATE)
(GETP SPS
DATA:STRUCTURE)))
TSUB))
(T TSUB))))
(VECTOR T NIL)))
AND IS USED IN (@ ANY2))
TYPE:OF:LIST))
(SETQ SOME:DELETIONS:LIST (CONS (CADR CHOICE)
SOME:DELETIONS:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
CONDITIONAL:DELETION))
BEING T)
(PUTPROPS CONDITIONAL:INSERTION BEING T
EXPLICIT:ARGS (E)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE PERHAPS WE WILL STICK IN A CONDITIONAL INSERTION STATEMENT, STICKING IN
AN (@ E)
-TYPE ELEMENT INTO ITS PARENT STRUCTURE)
HOW (TUPLE WE WILL ASK THE USER, PROBABLY)
WHY (TUPLE BECAUSE IF AN INSERTION IS NOT TO BE MADE, THEN WE WANT TO WIPE OUT ALL
TRACES OF THIS STATEMENT; IF ONE IS TO BE MADE, WE WILL NEED THE USER TO
GUIDE US SINCE THE DETAILS HERE DEPEND CRITICALLY UPON THE DETAILS HE HAS
IN MIND FOR THE PROGRAM)
META:CODE (VECTOR WE ASK THE USER)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE MODIFY:STRUCTURE)
SPECIALIZATIONS (VECTOR
(VECTOR
BOOLEAN
(VECTOR DO I, AT THIS POINT, CONDITIONALLY INSERT
(PROGN (SETQ PS
(COND ((MATCH (TUPLE P O S S I B L E : FRAG1)
(UNPACK ARG1))
ARG1)
(T (PACK (LIST (QUOTE POSSIBLE:)
ARG1)))))
(SETQ SPS (PACK (LIST (QUOTE SET:OF:)
(PLURAL PS))))
(SET SPS SPS)
(SET ARG1 ARG1)
(SET PS PS)
(SATISFY (VECTOR IS STRUCTURE
(LIST VECTOR SPS PS)))
(COND ((AND (MEMBER ARG1 IS:STRUCTURE:LIST)
(NOT (MEMBER (LIST VECTOR SPS PS)
IS:STRUCTURE:LIST)))
(SETQ PS (VECTOR I:DONT:KNOW:WHAT))
(SETQ SPS ARG1)
(SETQ ARG1 (COLON:BACK (CDDR (COLON:BREAK
ARG1)))))
(T ARG1)))
,OR A SIMILAR ELEMENT, SUCH AS (@ PS)
INTO THE DATA STRUCTURE (@ SPS)
??? PLEASE RESPOND YES OR NO; IF YOU SAY 'YES', THEN I
WILL PROBABLY HAVE TO ASK YOU SOME MORE QUESTIONS.)
AFFECTS
(VECTOR THE CONDITIONAL:INSERTION ALGORITHM)
NO:RESULTS
(QUOTE ((SETQ CODING:WARNING:LIST
(CONS (TUPLE 10 VECTOR DELETE ALL MENTION OF
(CADR CHOICE)
FROM ALL CODE GENERATED)
CODING:WARNING:LIST))))
BOTH:RESULTS
(QUOTE ((VECTOR NOTHING IN COMMON)))
YES:RESULTS
(QUOTE
((PUPRIN1
"
NOW WE MUST KNOW 2 THINGS:
(1) WHAT WE INSERT
(2) UNDER WHAT CONDITION WE DO THE INSERTION
NOTES ABOUT (1): IF WE ARE INSERTING AN ALREADY EXISTING THING, THEN
JUST GIVEITS NAME; IF IT IS NEW, GIVE AN EXPRESSION INDICATING HOW WE
GET IT, PERHAPS IN TERMS OF ARG1.
")
(PUPRINT (TUPLE RECALL THAT HERE, ARG1 IS INSTANTIATED AS
(@ ARG1)))
(PUPRIN1
"
NOTES ABOUT (2): YOU MAY REFER TO THE RESULT OF (1) AS ")
(PUPRIN1 (SETQ RS (PACK (TUPLE RESULT: (SETQ RESULT:COUNTER
(ADD1
RESULT:COUNTER)))))
)
(PUPRIN1
(CONCAT
". THIS WILL BE ESPECIALLY USEFUL IF (1) IS NOT SIMPLY
AN OLD NAME. ALSO, WE "
(COND ((MEMBER (LIST VECTOR SPS PS)
IS:STRUCTURE:LIST)
"DO")
(T "DO NOT"))
" ASSUME THAT PART OF
THE CONDITION (2) IS THE FACT THAT "))
(PUPRINT RS)
(PUPRIN1
" IS NOT ALREADY IN THE LIST. THIS NEED NOT BE RESTATED
BY THE USER.
USER: (1): ")
(SETQ RESULTANT (LIST:TRANSLATE (INVECTOR (PREAD))
T))
(PUPRIN1 "
USER: (2): ")
(SETQ CONDIT (LIST:TRANSLATE (INVECTOR (PREAD))
T))
(COND ((AND (MEMBER PS IS:STRUCTURE:LIST)
(NOT (MEMBER ARG1 IS:STRUCTURE:LIST)))
(COND ((NULL (GETP ARG1 BEING))
(SETQ BNAME PS)
(SETQ FNAME ARG1)
(SETQ CODE (GETP PS META:CODE))
(SATISFY (VECTOR IS BEING FNAME))))
(PUT ARG1 DATA:STRUCTURE
(COPY (SUBALLEVELS ARG1 PS (COPY (GETP PS
DATA:STRUCTURE)))))
(MAPC (MAPCAR (CDR (GETP PS META:CODE))
(QUOTE CADDR))
(FUNCTION
(LAMBDA (PROP)
(COND
((GETP PROP BEING)
(PUT PROP DATA:STRUCTURE
(APPEND (GETP PROP
DATA:STRUCTURE)
(LIST (QUOTE ALTERNATE)
ARG1 PS))))))))
(SETQ IS:STRUCTURE:LIST (CONS ARG1 IS:STRUCTURE:LIST))))
(COND ((EQUAL (CADR RESULTANT)
(QUOTE AND))
(SETQ RESULTANT (APPEND (VECTOR LIST:JOIN)
(CDDR RESULTANT)))))
(SETQ HTAL (CADR (MEMBER (QUOTE ACCESS)
(GETP ARG1 DATA:STRUCTURE))))
(SETQ TAL (COND ((LISTP HTAL)
(CDR HTAL))))
(SETQ RESULTANT (SUBPAIR (MAPCAR TAL (FUNCTION
(LAMBDA
(A)
(CAR (LAST A)))))
(MAPCAR TAL (FUNCTION (LAMBDA
(A2)
(CDADR A2))))
(COPY RESULTANT)
T))
(SOME TYPE:OF:LIST (FUNCTION (LAMBDA
(TOL)
(MATCH (VECTOR (CADR CHOICE)
TYPE OF
(VECTOR
CONDITIONAL:INSERTION)
IS FRAG1 USED IN
ANY2)
TOL))))
(SETQ SOME:INSERTIONS:LIST (CONS (CADR CHOICE)
SOME:INSERTIONS:LIST))
(SETQ
TYPE:OF:LIST
(CONS
(VECTOR
(CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(SETQ
CD
(VECTOR
PROGN
(VECTOR SETQ (@ RS)
(INVECTOR RESULTANT))
(VECTOR
COND
(VECTOR
(COND ((MEMBER (LIST VECTOR SPS PS)
IS:STRUCTURE:LIST)
(VECTOR AND (VECTOR NOT
(VECTOR MEMBER
(@ RS)
(@ SPS)))
(INVECTOR CONDIT)))
(T (INVECTOR CONDIT)))
(INVECTOR
(COND
((NOT:YET:INITIALIZED (EVAL RESULTANT))
(CONS
(QUOTE PROGN)
(MAPCONC
(CADR
(OUTVECTOR
(MEMBER (QUOTE INITIALIZE)
(GETP (EVAL RESULTANT)
DATA:STRUCTURE))))
(FUNCTION
(LAMBDA
(INI)
(LIST (CAR INI)
(COMMENT THIS INITIALIZES
(CAR (LAST INI)))))))
))))
(PROGN
(SETQ
TSUB
(SUBST
RS
(QUOTE X)
(CADDR
(CAR (OUTVECTOR
(CADR (MEMBER (QUOTE INSERT)
(GETP SPS
DATA:STRUCTURE)))))
)))
(COND
((AND (DETERMINE:ARG2:VALUE CHOICE)
(EQUAL (EVAL ARG2)
(SETQ
TS2
(CADR (MEMBER (QUOTE
ALTERNATE)
(GETP SPS
DATA:STRUCTURE)))))
)
(SUBST TS2 (CADDR (MEMBER (QUOTE ALTERNATE)
(GETP SPS
DATA:STRUCTURE)))
TSUB))
(T TSUB))))
(VECTOR T NIL))))
AND IS USED IN (@ ANY2))
TYPE:OF:LIST))
(SETQ CDFLAT (FLATTEN CD))
(MAPC CODING:WARNING:LIST
(FUNCTION (LAMBDA
(CW)
(COND ((AND (MATCH (TUPLE ANY1 VECTOR
COMMENT ANY2 IN
ANY3 UNDEFINED;
WILL BE GOTTEN
LATER; FRAG1)
CW)
(MEMBER ANY2 CDFLAT)
(MEMBER ANY3 CDFLAT))
(SETQ
CODING:WARNING:LIST
(CONS (COPY (SUBALLEVELS
(CADR CHOICE)
ANY3
(COPY CW)))
CODING:WARNING:LIST)))))))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
CONDITIONAL:INSERTION)))
(PUTPROPS DATA:STRUCTURE:DELETIONS BEING T
IDEN (((MATCH (TUPLE DELETE FRAG1 INTO ANY1)
LI)
(VECTOR DATA:STRUCTURE:INSERTIONS (@ ANY1)
(CAR FRAG1))))
IMPLICIT:ARGS (RESPONSE NTAG SARG EVER:DID PRECISE:CALL OUTER:FN PLACEMENT NCODE
DLOC)
EXPLICIT:ARGS (SNAME ENAME SINSERT)
EXPLICIT:ARGS:CHECK (AND (OR ENAME (SETQ ENAME
(COND ((MATCH (STRUCTURE (LIST ATOMS OF
TYPE ANY1))
(GETP SNAME META:CODE))
ANY1)
(T (QUOTE ATOM)))))
(OR SINSERT (SETQ SINSERT (CADR (MEMBER (QUOTE DELETE)
(GETP SNAME
DATA:STRUCTURE)))))
)
WHAT (TUPLE LOCATE THE PLACES IN THE CODE WHERE AN DELETION INTO THE (@ SNAME)
DATA STRUCTURE SHOULD BE MADE, AND FIX UP THE CODE UNDER CONTROL OF
THE USER)
HOW (TUPLE LOOK FOR ASSIGNMENTS X ← Y, WHERE X IS A KNOWN TYPE OF ELEMENT OF
(@ SNAME)
;THEN ASK THE USER IF, JUST AFTER GETTING THIS NEW X, WE SHOULD DELETE
IT INTO (@ SNAME)
AND, IF SO, UNDER WHAT CONDITIONS)
WHY (TUPLE BECAUSE A DATA STRUCTURE HAVING NO DELETIONS IS A VERY STRANGE
CONSTRUCT; ALSO, THE MOST LIKELY PLACE TO DELETE IS JUST AFTER A NEW
POTENTIAL ELEMENT IS CREATED)
META:CODE (PROGN
(SETQ EVER:DID 0)
(PUPRIN1
(CONCAT
" I AM NOT SURE WHETHER OR NOT WE SHOULD EVER
DELETE ELEMENT(S) FROM " SNAME ". SHOULD WE EVER?
USER: "))
(COND
((MEMBER (PREAD)
(TUPLE Y YES MAYBE))
(MAPCAR
(SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION
(LAMBDA
(B)
(SETQ SARG (CADR (MEMBER ENAME (TUPLE (DETERMINE:ARG:VALUE
(LIST VECTOR B))
ARG1
(DETERMINE:ARG2:VALUE
(LIST VECTOR B))
ARG2
(DETERMINE:ARG3:VALUE
(LIST VECTOR B))
ARG3))))
(COND
((PROGN (SETQ NTAG2 NIL)
(SETQ NTAG
(CAR (FIND:AND:TAG
(COND (SARG (TUPLE SET (@ SARG)
ANY1))
(T (TUPLE SETQ (@ ENAME)
ANY1)))
(GETP B META:CODE))))
NTAG2)
(PUPRINT (TUPLE I HAVE FOUND AND TAGGED THE ASSIGNMENTS TO)
)
(COND (SARG (PUPRINT (TUPLE (@ SARG)
,WHICH IS INSTANTIATED AS))))
(PUPRINT (TUPLE (@ ENAME)
,WHICH IS THE TYPE OF ELEMENT OF THE DATA
STRUCTURE (@ SNAME)
;SHOULD I DELETE A NEW LISP STATEMENT,
JUST AFTER THIS ASSIGNMENT, WHICH
CONDITIONALLY WILL DELETE THE NEW
(@ ENAME)
INTO
(@ SNAME)
? ALL THIS IS IN THE FUNCTION
(@ B)
.ANSWER YES, NO, OR UNSURE -- UNSURE MEANS
THAT WE SHOULD BE MORE SPECIFIC ABOUT THIS
ASSIGNMENT ....))
(COND
((EQUAL (SETQ RESPONSE (PREAD))
(QUOTE UNSURE))
(PUPRINT NTAG)
(PUPRIN1
"
THIS IS THE CODE AND THE PROPOSED PLACE OF THE CONDITIONAL DELETEION.
NOW YOU MUST ANSWER YES OR NO
USER: ")
(SETQ RESPONSE (PREAD))))
(COND
((EQUAL RESPONSE (QUOTE YES))
(SETQ EVER:DID (ADD1 EVER:DID))
(PUPRIN1
"
OK, TYPE IN THE CONDITION NOW.
IT SHOULD BE A PREDICATE, WHICH IS TRUE IF THE DELETEION IS TO BE MADE,
AND FALSE IF THE INSERTION IS NOT TO BE MADE.
USER: ")
(PUT
B META:CODE
(GETCODE
(SUBST (TUPLE COND
(TUPLE (OUTVECTOR
(TRANSLATE (INVECTOR
(PREAD))
T))
(SUBST (COND
(SARG)
(T (@ ENAME)))
(QUOTE X)
(CDDAR SINSERT))))
"***TAG***" NTAG)
B -1)))))))))
(COND
((NOT (ZEROP EVER:DID))
(VECTOR WE PUT IN A TOTAL OF (@ EVER:DID)
CONDITIONAL DELETIONS OF (PLURAL ENAME)
INTO
(@ SNAME)))
(T
(PUPRIN1
(CONCAT
"
I STILL HAVEN'T LOCATED ANY DELETEIONS AT ALL INTO THE DATA STRUCTURE
" SNAME "; PLEASE TELL ME WHEN I SHOULD (CONDITIONALLY) DURING THE
COURSE OF THE PROGRAM, DELETE A NEW MEMBER INTO " SNAME "
USER: "))
(SETQ HDLO (PREAD))
(COND
((MEMBER HDLO (TUPLE NOWHERE NEVER NONE))
(VECTOR THERE APPARENTLY ARE NO KNOWN DELETIONS INTO THE
DATA STRUCTURE))
(T
(SETQ DLOC (LOCATION:TRANSLATE HDLO))
(SETQ PRECISE:CALL (CAR DLOC))
(SETQ OUTER:FN (CADR DLOC))
(SETQ PLACEMENT (CADDR DLOC))
(SETQ NCODE (COPY (GETP OUTER:FN META:CODE)))
(SETQ NCODE (SELECTQ PLACEMENT (AFTER (FIND:AND:TAG
PRECISE:CALL
NCODE))
(BEFORE (FIND:AND:PRETAG PRECISE:CALL
NCODE))
(ERROR!)))
(PUPRIN1 (CONCAT "
OK, WHAT EXACTLY DO I DELETE INTO " SNAME "?
USER: "))
(SETQ RESPONSE (OUTVECTOR (TRANSLATE (INVECTOR (PREAD))
T)))
(PUPRIN1
(CONCAT
"
OK, NOW TELL ME WHE CONDITION IER WHICH I SHOULD DELETE IN
U IN
U" RESPONSE " IN
US" SNAME "ER: ***TA"))
(PUT
OUTER:FN META:CODE
(GETCODE
(SUBST (TUPLE COND
(TUPLE (OUTVECTOR (TRANSLATE
(INVECTOR (PREAD))
T))
(SUBST RESPONSE (QUOTE X)
(CDDAR SINSERT))))
"***TAG***" NCODE)
OUTER:FN -1))
(SETQ EVER:DID (ADD1 EVER:DID))
(VECTOR WE FOUND NO PLACE TO PUT AN DELETEION, SO WE HAD TO
QUERY THE USER, WHICH LED TO PUTTING A CONDITIONAL
DELETION INTO THE FUNCTION (@ OUTER:FN))))))))
(SETQ SOME:DELETIONS:LIST (CONS SNAME SOME:DELETIONS:LIST)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
MAIN:EFFECTS (((VECTOR SOME DELETIONS FRAG1)
(APPEND (VECTOR DATA:STRUCTURE:DELETIONS)
FRAG1))))
(PUTPROPS DATA:STRUCTURE:INSERTIONS BEING T
IDEN (((MATCH (TUPLE INSERT FRAG1 INTO ANY1)
LI)
(VECTOR DATA:STRUCTURE:INSERTIONS (@ ANY1)
(CAR FRAG1))))
IMPLICIT:ARGS (RESPONSE NTAG SARG EVER:DID PRECISE:CALL OUTER:FN PLACEMENT NCODE
DLOC)
EXPLICIT:ARGS (SNAME ENAME SINSERT)
EXPLICIT:ARGS:CHECK (AND (OR ENAME (SETQ ENAME
(COND ((MATCH (STRUCTURE (LIST ATOMS OF
TYPE ANY1)
)
(GETP SNAME META:CODE))
ANY1)
(T (QUOTE ATOM)))))
(OR SINSERT (SETQ SINSERT (CADR (MEMBER (QUOTE INSERT)
(GETP SNAME
DATA:STRUCTURE)))))
)
WHAT (TUPLE LOCATE THE PLACES IN THE CODE WHERE AN INSERTION INTO THE
(@ SNAME)
DATA STRUCTURE SHOULD BE MADE, AND FIX UP THE CODE UNDER CONTROL OF
THE USER)
HOW (TUPLE LOOK FOR ASSIGNMENTS X ← Y, WHERE X IS A KNOWN TYPE OF ELEMENT OF
(@ SNAME)
;THEN ASK THE USER IF, JUST AFTER GETTING THIS NEW X, WE SHOULD INSERT
IT INTO (@ SNAME)
AND, IF SO, UNDER WHAT CONDITIONS)
WHY (TUPLE BECAUSE A DATA STRUCTURE HAVING NO INSERTIONS IS A VERY STRANGE
CONSTRUCT; ALSO, THE MOST LIKELY PLACE TO INSERT IS JUST AFTER A NEW
POTENTIAL ELEMENT IS CREATED)
META:CODE (PROGN
(SETQ EVER:DID 0)
(PUPRIN1
(CONCAT
" I AM NOT SURE WHETHER OR NOT WE SHOULD EVER
INSERT ELEMENT(S) INTO " SNAME ". SHOULD WE EVER?
USER: "))
(COND
((MEMBER (PREAD)
(TUPLE Y YES MAYBE))
(MAPCAR
(SETDIFFERENCE IS:BEING:LIST SET:OF:BEINGS)
(FUNCTION
(LAMBDA
(B)
(SETQ SARG (CADR (MEMBER ENAME (TUPLE (DETERMINE:ARG:VALUE
(LIST VECTOR B))
ARG1
(DETERMINE:ARG2:VALUE
(LIST VECTOR B))
ARG2
(DETERMINE:ARG3:VALUE
(LIST VECTOR B))
ARG3))))
(COND
((PROGN (SETQ NTAG2 NIL)
(SETQ NTAG
(CAR (FIND:AND:TAG
(COND (SARG (TUPLE SET (@ SARG)
ANY1))
(T (TUPLE SETQ (@ ENAME)
ANY1)))
(GETP B META:CODE))))
NTAG2)
(PUPRINT (TUPLE I HAVE FOUND AND TAGGED THE ASSIGNMENTS
TO))
(COND (SARG (PUPRINT (TUPLE (@ SARG)
,WHICH IS INSTANTIATED AS))))
(PUPRINT (TUPLE (@ ENAME)
,WHICH IS THE TYPE OF ELEMENT OF THE DATA
STRUCTURE (@ SNAME)
;SHOULD I INSERT A NEW LISP STATEMENT,
JUST AFTER THIS ASSIGNMENT, WHICH
CONDITIONALLY WILL INSERT THE NEW
(@ ENAME)
INTO
(@ SNAME)
? ALL THIS IS IN THE FUNCTION
(@ B)
.ANSWER YES, NO, OR UNSURE -- UNSURE
MEANS THAT WE SHOULD BE MORE SPECIFIC
ABOUT THIS ASSIGNMENT ....))
(COND
((EQUAL (SETQ RESPONSE (PREAD))
(QUOTE UNSURE))
(PUPRINT NTAG)
(PUPRIN1
"
THIS IS THE CODE AND THE PROPOSED PLACE OF THE CONDITIONAL INSERTION.
NOW YOU MUST ANSWER YES OR NO
USER: ")
(SETQ RESPONSE (PREAD))))
(COND
((EQUAL RESPONSE (QUOTE YES))
(SETQ EVER:DID (ADD1 EVER:DID))
(PUPRIN1
"
OK, TYPE IN THE CONDITION NOW.
IT SHOULD BE A PREDICATE, WHICH IS TRUE IF THE INSERTION IS TO BE MADE,
AND FALSE IF THE INSERTION IS NOT TO BE MADE.
USER: ")
(PUT
B META:CODE
(GETCODE
(SUBST
(TUPLE COND
(TUPLE (OUTVECTOR (TRANSLATE
(INVECTOR (PREAD))
T))
(SUBST (COND (SARG)
(T (@ ENAME)))
(QUOTE X)
(CDDAR SINSERT))))
"***TAG***" NTAG)
B -1)))))))))
(COND
((NOT (ZEROP EVER:DID))
(VECTOR WE PUT IN A TOTAL OF (@ EVER:DID)
CONDITIONAL INSERTIONS OF (PLURAL ENAME)
INTO
(@ SNAME)))
(T
(PUPRIN1
(CONCAT
"
I STILL HAVEN'T LOCATED ANY INSERTIONS AT ALL INTO THE DATA STRUCTURE
" SNAME "; PLEASE TELL ME WHEN I SHOULD (CONDITIONALLY) DURING THE
COURSE OF THE PROGRAM, INSERT A NEW MEMBER INTO " SNAME "
USER: "))
(SETQ HDLO (PREAD))
(COND
((MEMBER HDLO (TUPLE NOWHERE NEVER NONE))
(VECTOR THERE APPARENTLY ARE NO KNOWN INSERTIONS INTO THE
DATA STRUCTURE))
(T
(SETQ DLOC (LOCATION:TRANSLATE HDLO))
(SETQ PRECISE:CALL (CAR DLOC))
(SETQ OUTER:FN (CADR DLOC))
(SETQ PLACEMENT (CADDR DLOC))
(SETQ NCODE (COPY (GETP OUTER:FN META:CODE)))
(SETQ NCODE (SELECTQ PLACEMENT (AFTER (FIND:AND:TAG
PRECISE:CALL
NCODE))
(BEFORE (FIND:AND:PRETAG PRECISE:CALL
NCODE))
(ERROR!)))
(PUPRIN1 (CONCAT "
OK, WHAT EXACTLY DO I INSERT INTO " SNAME "?
USER: "))
(SETQ RESPONSE (OUTVECTOR (TRANSLATE (INVECTOR (PREAD))
T)))
(PUPRIN1
(CONCAT
"
OK, NOW TELL ME WHAT THE CONDITION IS UNDER WHICH I SHOULD INSERT " RESPONSE " INTO " SNAME "?
USER: "))
(PUT
OUTER:FN META:CODE
(GETCODE
(SUBST (TUPLE COND
(TUPLE (OUTVECTOR
(TRANSLATE (INVECTOR (PREAD))
T))
(SUBST RESPONSE (QUOTE X)
(CDDAR SINSERT))))
"***TAG***" NCODE)
OUTER:FN -1))
(SETQ EVER:DID (ADD1 EVER:DID))
(VECTOR WE FOUND NO PLACE TO PUT AN INSERTION, SO WE HAD
TO QUERY THE USER, WHICH LED TO PUTTING A
CONDITIONAL INSERTION INTO THE FUNCTION
(@ OUTER:FN))))))))
(SETQ SOME:INSERTIONS:LIST (CONS SNAME SOME:INSERTIONS:LIST)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
MAIN:EFFECTS (((VECTOR SOME INSERTIONS FRAG1)
(APPEND (VECTOR DATA:STRUCTURE:INSERTIONS)
FRAG1))))
(PUTPROPS DEFER:DECISION BEING T
IDEN (((AND (EQUAL (CAR LI)
DEFER:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR DEFER:DECISION (CADR LI)))
((MATCH (QUOTE (DEFER THE DECISION ANY1))
LI)
(VECTOR DEFER:DECISION (@ ANY1))))
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK (MEMBER D UNDEFERRED:DECISION:LIST)
WHAT (TUPLE DEFER THE DECISION (@ D)
AS LONG AS POSSIBLE)
HOW (TUPLE DECIDE WHEN THE CONSEQUENCES OF DECISION (@ D)
WOULD NEXT AFFECT OUR WRITING THE PROGRAM CODE, AND THEN DEMONIZE THAT SITUATION)
WHY (TUPLE THE LONGER WE CAN DEFER ANY DECISION, INCLUDING (@ D)
,THE GREATER THE CHANCES THAT WE WILL HAVE GAINED ENOUGH NEW KNOWLEDGE OF THE
TASK THAT WHEN WE MUST FINALLY CONSIDER (@ D)
WE WILL KNOW ENOUGH TO ANSWER IT EASILY)
MAIN:EFFECTS (((VECTOR DEFERRED DECISION ANY1)
(VECTOR DEFER:DECISION (@ ANY1))))
WHEN ((UNDEFERRED:DECISION:LIST 40
(VECTOR BECAUSE THERE EXIST UNDEFERRED DECISIONS, SO WE MUST
LOOK AFTER THEM IN SOME WAY BEFORE PROCEDING))
((MEMBER D UNDEFERRED:DECISION:LIST)
89
(VECTOR BECAUSE (@ D)
IS ONE OF THOSE UNDEFERRED DECISIONS)))
META:CODE (PROGN (SETQ UNDEFERRED:DECISION:LIST (PULLOUT D UNDEFERRED:DECISION:LIST))
(SETQ SITU (WHEN:NEXT (VECTOR PUP REINVESTIGATE (@ D))))
(COND ((EQUAL (CAR SITU)
VECTOR)
(SETQ SITU (CDR SITU))))
(COND ((EVAL SITU)
(RESOLVE:DECISION (VECTOR (@ D)
SINCE
(@ SITU))))
((EQUAL SITU (LIST FOREVER))
T)
(T (SETQ DEFERRED:DECISION:LIST (CONS (VECTOR (@ D)
UNTIL
(@ SITU))
DEFERRED:DECISION:LIST)))))
AFFECTS (QUOTE ((WHEN:NEXT CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
INHIBIT:CURRENT:DEMONS T
IMPLICIT:ARGS (SITU))
(PUTPROPS ELEMENT BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE A STRUCTURE WHICH IS A MEMBER OF A LARGER STRUCTURE)
SPECIALIZATIONS (VECTOR (VECTOR DEFINITION (VECTOR WHAT IS AN ELEMENT)
AFFECTS
(VECTOR CODE INVOLVING ELEMENT)
ELEMENT))
COMPLEXITY:VECTOR (.3 .3 .3 .3 .1)
IDEN (((EQUAL (TUPLE ELEMENT)
LI)
(VECTOR ELEMENT)))
DATA:STRUCTURE T)
(PUTPROPS ENCODE BEING T
IDEN (((MATCH (QUOTE (ENCODE ANY1))
LI)
(CONS VECTOR LI)))
IMPLICIT:ARGS (FNAME FDESC F1 CODE FARGS YY ORIG:FUNC ARG:LIST ARG:COMMENTS PCOUNT FARGS1 FARGS2
TEMPFARGS CFLAT BNAME)
EXPLICIT:ARGS (FUNC)
EXPLICIT:ARGS:CHECK (PROGN
(SETQ ORIG:FUNC FUNC)
(AND (OR (AND (MATCH (VECTOR (VECTOR FRAG1)
NAME ANY1 FRAG2 ANY2)
FUNC)
(SETQ FDESC FRAG1)
(SETQ FNAME ANY1)
(SETQ BNAME ANY2)
(SETQ F1 (CADR FDESC)))
(COND ((ATOM FUNC)
NIL)
(T (SETQ FUNC (CADR FUNC))
NIL))
(AND (MEMBER T (MAPCAR (REVERSE TYPE:OF:LIST)
(FUNCTION
(LAMBDA
(TT)
(COND
((EQUAL (CADR TT)
FUNC)
(SETQ F1 (SETQ FDESC
(CADDDR (CDDDR TT))))
(SETQ FNAME FUNC)
(SETQ
BNAME
(CAR (OUTVECTOR (CADDR (CDDR TT)))))
T))))))
(COND ((NULL F1)
(SETQ F1 FNAME)
(SETQ TYPE:OF:LIST (NCONC1 TYPE:OF:LIST
(VECTOR (@ F1)
IS
(SUBPAIR (GETP BNAME
EXPLICIT:ARGS)
(CDR FUNC)
(GETP BNAME
META:CODE)
T)))))
((MEMBER (VECTOR (@ FUNC)
TYPE OF (LIST VECTOR BNAME))
ENCODABLE:SECTION:LIST))
((MEMBER FUNC ENCODABLE:SECTION:LIST)))))
(OR (SATISFY (VECTOR ENCODABLE SECTION ORIG:FUNC))
(SATISFY (VECTOR ENCODABLE SECTION FUNC)))))
WHAT (VECTOR ENCODE A FUNCTION NAMED (@ FNAME)
TO ACCOMPLISH (@ BNAME)
BY USING, AMONG OTHER FACTS, (@ FDESC))
HOW (VECTOR DEFINE (@ FNAME)
USING
(@ FDESC))
WHY (VECTOR (@ FNAME)
IS CURRENTLY UNDEFINED)
META:CODE (PROGN (MAPC TYPE:OF:LIST (FUNCTION (LAMBDA (PC)
(COND ((MATCH (VECTOR (@ F1)
IS FRAG1)
PC)
(SETQ CODE FRAG1))))))
(COND
((NULL CODE)
(PUPRIN1 "
PUP IS NOW GOING TO ENCODE THE PIECE
")
(PUPRETTYPRINT (LIST (LIST (OUTVECTOR F1))))
(PUPRIN1 "
OF THE FUNCTION ")
(PUPRIN1 FNAME)
(PUPRIN1 " INTO LISP. FUNCTION NAMES WILL
BE QUERIED IN PREORDER, AS NEEDED.
")
(SETQ ARG:LIST (CDR (SASSOC FNAME (OUTVECTOR FN:CALL:LIST))))
(SETQ CODE (LIST (GETCODE (OUTVECTOR F1)
FNAME 1)))
(SETQ FARGS (INTERSECTION FARGS FARGS))
(COND ((GREATERP (LENGTH FARGS)
(LENGTH ARG:LIST))
(SETQ FARGS (SETDIFFERENCE FARGS TRIVIAL:BEING:LIST))))
(COND ((GREATERP (LENGTH FARGS)
(LENGTH ARG:LIST))
(SETQ FARGS (SETDIFFERENCE FARGS ARG:LIST))))
(COND ((LESSP (LENGTH FARGS)
(LENGTH ARG:LIST))
(SETQ FARGS (APPEND FARGS (DUMMIES (DIFFERENCE (LENGTH ARG:LIST)
(LENGTH FARGS)))))))
(SETQ FARGS (FIRSTN (LENGTH ARG:LIST)
FARGS))
T)
(T (SETQ FARGS (APPEND (GETP (CAR FDESC)
EXPLICIT:ARGS)
(GETP (CAR FDESC)
IMPLICIT:ARGS)))
(SETQ UNDEFINED:SECTION:LIST
(SETUNION UNDEFINED:SECTION:LIST
(SETDIFFERENCE (OUTNIL (FLATTEN CODE))
(APPEND WRITTEN:PROGRAMS:LIST PUP5FNS
PRIMITIVE:PROGRAMS:LIST
PRIMITIVE:VARS:LIST IS:BEING:LIST
SET:OF:BEING:PARTS PUP5VARS))))))
(SETQ FARGS1 (MAPCONC FARGS (FUNCTION (LAMBDA (FF)
(COND ((MATCH (TUPLE A R G FRAG1)
(UNPACK FF))
(LIST FF)))))))
(SETQ FARGS2 (SETDIFFERENCE FARGS FARGS1))
(SETQ FARGS1 (SORT (COPY FARGS1)))
(SETQ TEMPFARGS NIL)
(SETQ PCOUNT 0)
(MAPC FARGS (FUNCTION (LAMBDA NIL (SETQ PCOUNT (ADD1 PCOUNT))
(COND ((MATCH (TUPLE A R G (@ PCOUNT))
(UNPACK (CAR FARGS1)))
(SETQ TEMPFARGS (NCONC1 TEMPFARGS
(CAR FARGS1)))
(SETQ FARGS1 (CDR FARGS1)))
(T (SETQ TEMPFARGS (NCONC1 TEMPFARGS
(CAR FARGS2)))
(SETQ FARGS2 (CDR FARGS2)))))))
(SETQ FARGS TEMPFARGS)
(COND ((AND (NOT (MATCH (COMMENT IN ALL CALLS TO DATE, ARG2 FRAG1)
(MEMBER COMMENT (CDR (MEMBER COMMENT (MEMBER
COMMENT
(SETQ CFLAT (FLATTEN CODE))))
))))
(MEMBER (QUOTE ARG3)
CFLAT))
(SETQ CODE (CONS (COMMENT IN ALL CALLS TO DATE, ARG3 IS INSTANTIATED AS
(DETERMINE:ARG3:VALUE CHOICE))
CODE))))
(COND ((AND (NOT (MATCH (COMMENT IN ALL CALLS TO DATE, ARG2 FRAG1)
(MEMBER COMMENT (CDR (MEMBER COMMENT CFLAT)))))
(MEMBER (QUOTE ARG2)
CFLAT))
(SETQ CODE (CONS (COMMENT IN ALL CALLS TO DATE, ARG2 IS INSTANTIATED AS
(DETERMINE:ARG2:VALUE CHOICE))
CODE))))
(COND ((AND (NOT (MATCH (COMMENT IN ALL CALLS TO DATE, ARG1 FRAG1)
(MEMBER COMMENT CFLAT)))
(MEMBER (QUOTE ARG1)
CFLAT))
(SETQ CODE (CONS (COMMENT IN ALL CALLS TO DATE, ARG1 IS INSTANTIATED AS
(DETERMINE:ARG:VALUE CHOICE))
CODE))))
(COND ((AND ARG2 (SETQ ARG2LIST (DETERMINE:ALL:ARG2:VALUES CHOICE))
(CDR (SETQ ARG2LIST (SETINTERSECTION ARG2LIST ARG2LIST))))
(SETQ CODE
(CONS (COMMENT I SEE THAT WE MAY ACTUALLY CALL THE FUNCTION WITH ARG2
ANY OF THE FOLLOWING: (INVECTOR ARG2LIST))
CODE))))
(COND ((AND ARG1 (SETQ ARG1LIST (DETERMINE:ALL:ARG:VALUES CHOICE))
(SETQ ARG1LIST (SETINTERSECTION ARG1LIST ARG1LIST))
(CDR ARG1LIST))
(SETQ CODE
(CONS (COMMENT I SEE THAT WE MAY ACTUALLY CALL THE FUNCTION WITH ARG1
ANY OF THE FOLLOWING: (INVECTOR ARG1LIST))
CODE))))
(EVAL (LIST (QUOTE DEFINEQ)
(LIST FNAME (APPEND (LIST (COND ((GETP BNAME NLAMBDA)
NLAMBDA)
(T (QUOTE LAMBDA))))
(LIST (COND (FARGS)
(T NIL)))
CODE))))
(PUPRIN1 "
PUP NOW DEFINES THIS FUNCTION:
")
(PUPRETTYPRINT (LIST FNAME))
(LIST (VECTOR WE DEFINE THE FUNCTION (@ FNAME)
AS:
(INVECTOR CODE))))
POST:REQUISITES ((VECTOR IS BEING FNAME))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS EXTRACT:RELEVANT:SUBSET IDEN (((AND (EQUAL (CAR LI)
EXTRACT:RELEVANT:SUBSET)
(EQUAL (LENGTH LI)
2))
(VECTOR EXTRACT:RELEVANT:SUBSET (TRANSLATE (CADR LI)
T))))
BEING T
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE EXTRACT THE SMALL NUCLEUS OF RELEVANT INFO FROM (@ NEW:INFO))
HOW (TUPLE BY DELETING ALL THE IRRELEVANT INFO FROM (@ NEW:INFO))
WHY (TUPLE ONLY A SMALL AMOUNT OF INFO IS RELEVANT TO ANY SPECIFIC PROBLEM, AND PUP
CANNOT HANDLE A LARGE MASS OF INFO EFFICIENTLY)
WHEN (((GREATERP (SIZE NEW:INFO)
50)
70
(QUOTE (BECAUSE IF THE NEW INFO IS OVER 50 TOKENS LONG, THEN WE CANNOT
EFFICIENTLY COMPREHEND IT)))
((LESSP (SIZE NEW:INFO)
12)
-80
(QUOTE (BECAUSE IF THE NEW INFO IS LESS THAN A DOZEN TOKENS LONG THEN WE
SHOULD EASILY BE ABLE TO PROCESS IT AS IT IS))))
META:CODE (PROGN (USE:PROGRAMMING:KNOWLEDGE APPLIED TO NEW:INFO SO:AS:TO KEEP
(VECTOR RELEVANT NEW:INFO))
(SETQ RELEVANT:INFO:LIST (CONS NEW:INFO RELEVANT:INFO:LIST)))
EXPLICIT:ARGS:CHECK (MEMBER NEW:INFO NEW:INFO:LIST)
MAIN:EFFECTS (((VECTOR RELEVANT INFO ANY1)
(VECTOR EXTRACT:RELEVANT:SUBSET (@ ANY1))))
AFFECTS (QUOTE ((APPLY:PROGRAMMING:KNOWLEDGE CALLED)))
COMPLEXITY:VECTOR (.3 .6 .6 .5 .1))
(PUTPROPS FILL:IN:UNDEFINED:SECTION BEING T
IDEN (((EQUAL (CAR LI)
FILL:IN:UNDEFINED:SECTION)
(VECTOR FILL:IN:UNDEFINED:SECTION (CADR LI))))
IMPLICIT:ARGS (OLD:DO:LIST XTHING)
EXPLICIT:ARGS (PROGRAM)
EXPLICIT:ARGS:CHECK UNDEFINED:SECTION:LIST
WHAT (VECTOR FILL IN AN UNDEFINED SECTION OF CODE AND ADD IT TO THE PROGRAM
(@ PROGRAM))
HOW (VECTOR CHOOSE THE SIMPLEST UNDEFINED PIECE AND ENCODE IT)
WHY (VECTOR BECAUSE ALL PIECES OF CODE MUST BE DEFINED OR THE PROGRAM WONT RUN)
WHEN ((UNDEFINED:SECTION:LIST 80
(TUPLE BECAUSE UNDEFINED:SECTION:LIST CONTAINS
PIECES OF CODE AS YET UNDEFINED))
((NULL UNDEFINED:SECTION:LIST)
-1000
(TUPLE BECAUSE NO PIECES OF CODE ARE KNOWN AND YET NOT YET DEFINED))
((SOME CODING:WARNING:LIST (FUNCTION (LAMBDA (COWL)
(LESSP (IMPROBABILITY:COMPLEX
COWL)
21))))
-150
(TUPLE BECAUSE A VERY EASY-TO-DO YET IMPORTANT FIXUP IS PENDING; IT IS
EASIER TO DO IT NOW THAN TO KEEP REMEMBERING IT AND DO IT LATER))
((SETINTERSECTION ENCODABLE:SECTION:LIST UNDEFINED:SECTION:LIST)
96
(TUPLE BECAUSE WE KNOW ENOUGH TO CODE EACH OF THE FOLLOWING SECTIONS:
(INVECTOR (SETINTERSECTION UNDEFINED:SECTION:LIST
ENCODABLE:SECTION:LIST)))))
META:CODE (COND ((SETQ NEW:PIECE (ENCODE CHOICE))
(SETQ UNDEFINED:SECTION:LIST (PULLOUT CHOICE
UNDEFINED:SECTION:LIST))
(COND ((MATCH (VECTOR ANY1 TYPE OF (VECTOR ANY2))
CHOICE)
(SETQ UNDEFINED:SECTION:LIST (PULLOUT (LIST VECTOR ANY2)
UNDEFINED:SECTION:LIST))))
(SETQ ENCODABLE:SECTION:LIST (PULLOUT CHOICE
ENCODABLE:SECTION:LIST))
(SETQ ENCODABLE:SECTION:LIST (PULLOUT (CADR CHOICE)
ENCODABLE:SECTION:LIST))
(SET PROGRAM (APPEND (EVAL PROGRAM)
NEW:PIECE)))
(T (SETQ DOING:PUP:LIST (CDDR DOING:PUP:LIST))
(SETQ PUP:WANTS:LIST (CONS (VECTOR MORE INFO RELEVANT TO
MAKING (@ CHOICE)
CODABLE)
PUP:WANTS:LIST))
NIL))
COMMENTS ((SETQ OLD:DO:LIST DOING:PUP:LIST)
(SETQ CHOICE (INVECTOR (MINIMUM (COND ((SETINTERSECTION
UNDEFINED:SECTION:LIST
ENCODABLE:SECTION:LIST))
(T UNDEFINED:SECTION:LIST))
FAST:BEING:COMPLEX)))
(SETQ DOING:PUP:LIST (CONS CHOICE DOING:PUP:LIST))
(SATISFY
(VECTOR
TYPE OF
(VECTOR
(SETQ
XTHING
(VECTOR
(PROG1 (COND ((ATOM CHOICE)
(SETQ TC CHOICE))
((MATCH (VECTOR ANY1 TYPE OF (VECTOR ANY2))
CHOICE)
(SETQ TC ANY1)
ANY2)
(T (SETQ TC (CAR (OUTVECTOR CHOICE)))))
(SETQ DOING:PUP:LIST
(CONS (INVECTOR (SASSOC TC (OUTVECTOR
FN:CALL:LIST)))
DOING:PUP:LIST))
(MAPC (CDR (SASSOC TC (OUTVECTOR FN:CALL:LIST)))
(FUNCTION
(LAMBDA (AA)
(COND
((ATOM AA)
(SATISFY
(VECTOR TYPE OF
(VECTOR (LIST VECTOR AA)
HAS BEEN STUDIED))
)))))))))
HAS BEEN STUDIED))
(AND (NOT (CAR (NLSETQ (SASSOC TC (OUTVECTOR OLD:DO:LIST)))))
(SOME TYPE:OF:LIST (FUNCTION
(LAMBDA (TOLL)
(AND (MATCH (VECTOR ANY1 TYPE OF (@ XTHING)
FRAG1)
TOLL)
(NOT (EQUAL ANY1 TC))))))
T)))
AFFECTS (QUOTE ((ENCODE CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS FOREACH BEING T
EXPLICIT:ARGS (X IN XSET DO ACTION)
EXPLICIT:ARGS:CHECK T
NLAMBDA T
NON:EVAL:ARGS T
WHAT (TUPLE GO THROUGH THE KNOWN SPACE OF (PLURAL X)
,WHICH IS (@ XSET)
,AND PERFORM (@ ACTION)
ON EACH, UNTIL SOME SPECIFIED TERMINATION CONDITION IS REACHED)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE LOOP REPEATEDLY)
SPECIALIZATIONS (VECTOR
(VECTOR
BOOLEAN
(VECTOR I ASSUME THAT I STOP AFTER EXAMINING ALL (PLURAL X)
IN
(@ XSET)
; DO I ALSO STOP AFTER SOME CONDITION 'C' BECOMES TRUE?)
COMMENT
(COMMENT THIS CONDITION 'C' SHOULD BE A PREDICATE, WHOSE SINGLE ARGUMENT IS
(@ X)
.'C' WORKS LIKE AN 'UNTIL' CLAUSE IN AN ITERATIVE STATEMENT. WE TEST
(PLURAL X)
UNTIL ONE OF THEM MAKES 'C' HAVE A NON-NULL VALUE. AT THAT TIME THE
FOREACH FUNCTION WILL RETURN A VALUE AND END.)
AFFECTS
(VECTOR THE FOREACH ALGORITHM)
NO:RESULTS
(QUOTE ((SETQ DELTA:SECTION:1
(VECTOR COMMENT IF A CONDITIONAL TERMINATION IS LATER ADDED, IT
WILL PROBABLY REPLACE THIS COMMENT))
(SETQ DELTA:SECTION:2 (VECTOR GO (@ TEMPL)))))
BOTH:RESULTS
(QUOTE
((SETQ ARG:COMMENTS NIL)
(SETQ ARG:COUNTER 0)
(SETQ FCALL (SASSOC (CADR CHOICE)
(OUTVECTOR FN:CALL:LIST)))
(MAP2C (CDR FCALL)
(GETP FOREACH EXPLICIT:ARGS)
(FUNCTION (LAMBDA (FA1 FA2)
(SETQ ARG:COUNTER (ADD1 ARG:COUNTER))
(SET (PACK (TUPLE ARG (@ ARG:COUNTER)))
FA1)
(COND ((MEMBER FA1 TRIVIAL:BEING:LIST)
(SET FA2 FA1))
(T (SET FA2 (PACK (TUPLE ARG (@ ARG:COUNTER)))
)
(SETQ ARG:COMMENTS
(NCONC1 ARG:COMMENTS
(COMMENT IN ALL CALLS TO
DATE, (EVAL FA2)
IS BOUND TO
(INCOMMENT FA1))))))
)))
(SETQ
TYPE:OF:LIST
(CONS (VECTOR (CADR CHOICE)
TYPE OF (INVECTOR (LAST (CADR D)))
IS
(APPEND (VECTOR PROGN)
ARG:COMMENTS
(LIST (TUPLE PROG
(VECTOR (SETQ
TRESULT
(COLON:BACK
(TUPLE RESULT
(SETQ RESULT:COUNTER
(ADD1
RESULT:COUNTER)))))
)
(VECTOR SETQ
(SETQ
EV:SET
(COLON:BACK
(LIST (QUOTE EVAL)
XSET)))
(VECTOR EVAL (@ XSET)))
(SETQ TEMPL
(COLON:BACK
(TUPLE LABEL (SETQ
LABEL:COUNTER
(ADD1 LABEL:COUNTER))))
)
(VECTOR COND
(VECTOR (VECTOR NULL
(@ EV:SET))
(VECTOR SET
(@ X)
FAILURE:VALUE)
(VECTOR RETURN
EXHAUSTION:VALUE)))
(VECTOR SET (@ X)
(VECTOR CAR (@ EV:SET)))
(VECTOR SETQ (@ EV:SET)
(VECTOR CDR (@ EV:SET)))
(VECTOR SETQ (@ TRESULT)
(VECTOR EVAL (@ ACTION)))
(EVAL DELTA:SECTION:1)
(EVAL DELTA:SECTION:2)))))
TYPE:OF:LIST))
(COND ((GETP XSET DATA:STRUCTURE))
(T (SETQ CODING:WARNING:LIST (CONS (TUPLE 95 VECTOR (EVAL XSET)
IS A DATA STRUCTURE, WITH
ELEMENTS OF TYPE
(EVAL X)
;BUT NO ACCESSION
INFORMATION IS KNOWN)
CODING:WARNING:LIST))))
(SETQ CODING:WARNING:LIST
(APPEND (LIST (TUPLE 45 VECTOR COMMENT WARNING FAILURE:VALUE IN
(CADR CHOICE)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY NIL OR
A LITERAL SUCH AS FAIL FAILURE OR NOTHING SINCE
(VECTOR WHEN NO (@ ARG1)
IN
(@ ARG3)
SUFFICES, WE MUST BIND (@ ARG1)
TO SOME SPECIAL VALUE TO DISTINGUISH IT
FROM THE LAST 'SUCCESSFUL BINDING-- TO
THE LAST ELEMENT OF (@ ARG3)))
(TUPLE 45 VECTOR COMMENT WARNING EXHAUSTION:VALUE IN
(CADR CHOICE)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY
(@ TRESULT)
SINCE
(VECTOR NO EXISTING (@ ARG1)
IN
(@ ARG3)
WILL SUFFICE. WE MUST KNOW WHAT VALUE TO
RETURN.))
(TUPLE 45 VECTOR COMMENT WARNING
(PACK (TUPLE INITIAL:VALUE:OF: (EVAL XSET)))
IN GLOBAL:CONTEXT:0; WILL BE GOTTEN LATER;
PROBABLY NIL OR THE INITIAL STATE OF KNOWLEDGE
ABOUT (COLON:BACK (CDDR (COLON:BREAK
(EVAL XSET))))))
CODING:WARNING:LIST))
(SETQ ENCODABLE:SECTION:LIST (CONS (CADR CHOICE)
ENCODABLE:SECTION:LIST))))
YES:RESULTS
(QUOTE
((SETQQ
DELTA:SECTION:1
(VECTOR
COND
(VECTOR
(SETQ
UC
(PROGN
(PUPRIN1
"
PLEASE TYPE IN A PREDICATE EQUIVALENT TO THIS UNTIL CONDITION 'C'.
USER: ")
(SETQ RESULT:BINDING:LIST
(CONS (LIST (TUPLE THE RESULT OF ACTION)
TRESULT)
RESULT:BINDING:LIST))
(SETQ
RESULT:BINDING:LIST
(CONS (LIST (TUPLE THE RESULT OF
(COND ((SOME ARG:COMMENTS
(FUNCTION
(LAMBDA
(ACM)
(MATCH (COMMENT
IN ALL CALLS TO
DATE, (@ ACTION)
IS BOUND TO
(COMMENT ANY2 FRAG1)
)
ACM))))
(SETQ
RESULT:BINDING:LIST
(CONS (LIST (TUPLE THE RESULT OF
(@ ACTION))
TRESULT)
RESULT:BINDING:LIST))
ANY2)
(ACTION)))
TRESULT)
RESULT:BINDING:LIST))
(TRANSLATE (INVECTOR (PREAD))
T)))
(VECTOR RETURN UNTIL:CONDITION:VALUE))
(VECTOR T (VECTOR GO (@ TEMPL)))))
(SETQQ DELTA:SECTION:2 (COMMENT AT THE TIME THAT (CADR CHOICE)
WAS CODED, THE UNTIL CONDITION VALUE WAS
LEFT UNDEFINED))
(SETQ CODING:WARNING:LIST
(CONS (TUPLE 45 VECTOR COMMENT WARNING UNTIL:CONDITION:VALUE IN
(CADR CHOICE)
UNDEFINED; WILL BE GOTTEN LATER; PROBABLY EITHER NIL OR
(COMMENT EVAL UNTIL:CONDITION)
OR
(COMMENT EVAL (@ X))
SINCE
(VECTOR THE UNTIL:CONDITION HAS BECOME TRUE FOR THE FIRST
TIME. WE MUST KNOW WHAT VALUE TO RETURN))
CODING:WARNING:LIST))))
FOREACH)))
(PUTPROPS GET:DATA:STRUCTURE BEING T
IDEN (((MATCH (TUPLE IS STRUCTURE ANY1)
LI)
(VECTOR GET:DATA:STRUCTURE ANY1 NIL)))
IMPLICIT:ARGS (SCODE STYPE)
EXPLICIT:ARGS (SNAME ENAME)
EXPLICIT:ARGS:CHECK (AND SNAME (OR (NULL ENAME)
(LISTP (GETP ENAME DATA:STRUCTURE))
(SATISFY (VECTOR IS STRUCTURE ENAME))))
WHAT (TUPLE GET THE DETAILS OF INITIALIZATION, ACCESSION, INSERTION, AND DELETION FOR
THE CURRENTLY VAGUE DATA STRUCTURE (@ SNAME))
HOW (TUPLE SELECT AN INTERNAL REPRESENTATION FOR (@ SNAME)
AND, IF NECESSARY, FOR A TYPICAL ELEMENT (@ ENAME)
OF
(@ SNAME)
,AND THEN LET THAT REPRESENTATION DICTATE THE STRUCTURE ACCESSION ROUTINES)
WHY (TUPLE BECAUSE EVERY DATA STRUCTURE MUST HAVE SOME DEFINITE INTERNAL REPRESENTATION,
AND THE DETAILS OF THE REPRESENTATION IMPLY WHAT THE EFFICIENT ACCESS
ALGORITHMS MUST BE)
META:CODE (PROG1
(COND
((EQUAL T (GETP SNAME DATA:STRUCTURE))
(SETQ STYPE (SELECT:STRUCTURE:TYPE (SETQ SCODE (GETP SNAME META:CODE))))
(PUT SNAME DATA:STRUCTURE (EVAL (EVAL (PACK (LIST STYPE (QUOTE :SETUP)))))
))
(T
(PUPRIN1
"
PUP: SORRY TO BOTHER YOU, BUT I MUST KNOW IF THE FOLLOWING IS A
DATA STRUCTURE: ")
(PUPRIN1 SNAME)
(PUPRIN1 ". PLEASE ANSWER YES OR NO
USER: ")
(COND ((MEMBER (PREAD)
(VECTOR Y YES MAYBE))
(SETQ CODE (TUPLE STRUCTURE (TUPLE LIST ATOMS OF TYPE
(@ ENAME))))
(SETQ BNAME LIST:STRUCTURE)
(SETQ FNAME SNAME)
(SATISFY (VECTOR IS BEING FNAME))
(PUT SNAME DATA:STRUCTURE
(EVAL (EVAL (PACK (TUPLE (SELECT:STRUCTURE:TYPE
(SETQ SCODE (GETP SNAME META:CODE)
))
:SETUP)))))))))
(COND ((GETP SNAME DATA:STRUCTURE)
(SETQ CODING:WARNING:LIST (NCONC1 CODING:WARNING:LIST
(TUPLE (COND (ENAME 100)
(266))
VECTOR WARNING WE HAVE FOUND
NO INSERTIONS INTO
(@ SNAME)
DATA STRUCTURE)))
(SETQ CODING:WARNING:LIST (NCONC1 CODING:WARNING:LIST
(TUPLE (COND (ENAME 101)
(267))
VECTOR WARNING WE HAVE FOUND
NO DELETIONS INTO
(@ SNAME)
DATA STRUCTURE)))
(SETQ IS:STRUCTURE:LIST (CONS SNAME (CONS (LIST VECTOR SNAME ENAME)
IS:STRUCTURE:LIST))))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
MAIN:EFFECTS (((VECTOR IS STRUCTURE ANY1)
(COND ((MATCH (VECTOR ANY2 ANY3)
ANY1)
(LIST VECTOR GET:DATA:STRUCTURE ANY2 ANY3))
(T (VECTOR GET:DATA:STRUCTURE (@ ANY1)
NIL))))))
(PUTPROPS GET:HOLD:OF BEING T
EXPLICIT:ARGS (ENTITY)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE GET (@ ENTITY)
INTO PUP'S AWARENESS)
HOW (TUPLE SEE IF (@ ENTITY)
IS ALREADY KNOWN; IF NOT, TRY TO COMPUTE IT; IF THIS ALSO FAILS, ASK THE USER ABOUT
IT)
WHY (TUPLE PUP NEEDS (@ ENTITY)
AT THIS POINT IN TIME)
META:CODE (OR (TAKE:HOLD:OF ENTITY)
(ASK:USER:ABOUT ENTITY))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
NLAMBDA T
SPECIALIZATIONS (VECTOR (VECTOR BOOLEAN (VECTOR DOES AN ALGORITHM ALREADY EXIST WHICH GETS
PRECISELY (@ ARG1))
AFFECTS
(VECTOR WHETHER WE CAN STOP THE GETTING ACTIVITY AND -- INSTEAD
-- WORK ON IMPLEMENTING)
WHEN
(VECTOR BEFORE ANY MORE ROUTINES ARE FINALIZED)
WHY
(VECTOR BECAUSE WE MAY NOT REALLY WANT A GETTING ROUTINE AFTER
ALL; WE MAY INSTEAD WANT AN IMPLEMENTING TYPE OF
ROUTINE.)
GET:HOLD:OF)
(VECTOR BOOLEAN (VECTOR DOES AN ALGORITHM EXIST WHICH GETS
(@ ARG1)
AND PERHAPS SOME OTHER STUFF)
AFFECTS
(VECTOR WHETHER WE CAN STOP TRYING TO 'GET' AND INSTEAD TRY TO
'IMPLEMENT')
WHEN
(VECTOR BEFORE ANY GET:HOLD:OF ROUTINES ARE FINALIZED)
WHY
(VECTOR BECAUSE TO DO SO EARLIER WOULD PRECLUDE THE CHANCE OF A
TRIVIAL SOLUTION TO THE GETTING; TO DO SO LATER MIGHT
CAUSE UNNECESSARY CODE TO BE WRITTEN)
GET:HOLD:OF)
(VECTOR ALTERNATIVES (VECTOR NO:ERROR:RECOVERY BACKTRACK:ERROR:RECOVERY
CORRECT:ERROR:AND:PROCEED:ERROR:RECOVERY)
AFFECTS
(VECTOR STORAGE OF INTERMEDIATE RESULTS)
WHEN
(VECTOR AFTER ALL GET:HOLD:OF ROUTINES ARE FINALIZED)
GET:HOLD:OF)
(VECTOR SOMEOF (VECTOR COMPUTE SEARCH GENERATE:AND:TEST)
COMMENT
(VECTOR THE SEARCH REFERS TO A KNOWN, FINITE SPACE; THE
GENERATE AND TEST REFERS TO AN UNKNOWN, INFINITE SET)
AFFECTS
(VECTOR THE GET:HOLD:OF ALGORITHM)
GET:HOLD:OF)))
(PUTPROPS GET:NAME BEING T
IDEN (((AND (EQUAL (CAR LI)
CALL)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI)))
((AND (EQUAL (CAR LI)
NAME)
(EQUAL (LENGTH LI)
3))
(VECTOR GET:NAME (CADR LI)
(CADDR LI))))
IMPLICIT:ARGS (TEMP1 NE EV:NEW:NAME TEMPINT)
EXPLICIT:ARGS (EXPRESSION NEW:NAME)
WHAT (TUPLE IDENTIFY THE NEW:NAME (@ NEW:NAME)
WITH THE EXPRESSION (@ EXPRESSION))
HOW (TUPLE PUP WILL ASK THE USER WHAT HE WISHES TO CALL (@ EXPRESSION))
WHY (TUPLE BOTH PUP AND THE USER MAY NEED TO REFER TO (@ EXPRESSION))
WHEN ((T (COND ((MEMBER EXPRESSION NAMED:EXPRESSION:LIST)
-90)
(T 50))
(QUOTE (BECAUSE MOST OBJECTS SHOULD HAVE NO MORE AND NO LESS THAN ONE NAME))))
META:CODE (COND
((OR (NUMBERP (CAR (LAST (COLON:BREAK EV:NEW:NAME))))
(AND (MATCH (VECTOR ANY2)
EXPRESSION)
(NUMBERP (CAR (LAST (COLON:BREAK (CADR EXPRESSION)))))))
(PUPRIN1
"
HMMMMM..... IT SEEMS I'VE SEEN THIS IDENTIFIER BEFORE. I WON'T NEED
YOUR INTERACTION AFLL. SORRY TO TROUBLE YOU.
IS TH")
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((ATOM (EVAL NEW:NAME))
(EVAL NEW:NAME))
(T (CADR (EVAL NEW:NAME))))
(CADR EXPRESSION))
(SETQ OLDNAME:TAG T)
(SETQ NAMED:EXPRESSION:LIST (CONS EXPRESSION NAMED:EXPRESSION:LIST)))
(T
(COND ((MEMBER EXPRESSION NAMED:EXPRESSION:LIST)
(TERPRI)
(PUPRIN1 (CONCAT "IS THIS THE SAME AS A " EXPRESSION
" WHICH WE'VE ALREADY SEEN AND NAMED?
USER: "))
(SETQ TEMP1 (MEMBER (PREAD)
(QUOTE (Y YES MAYBE))))))
(COND (TEMP1 (SETQ NE (INTERSECTION (SETQ TEMPINT
(MAPCONC
TYPE:OF:LIST
(FUNCTION
(LAMBDA (TOL)
(COND
((MATCH (VECTOR
ANY1 TYPE OF
(@ EXPRESSION)
FRAG1)
TOL)
(LIST ANY1)))))))
TEMPINT))))
(COND
((CDR NE)
(PUPRIN1
(CONCAT
NE " ARE SUCH NAMES. "
"
SINCE THERE IS MORE THAN ONE, PLEASE TYPE IN TO ME THE NAME, AGAIN,
OF ONE OF THE ABOVE" "
OR TYPE IN ] IF THE NAME YOU WANT ISNT REALLY ONE OF THESE AFTER ALL.
USER: "))
(SETQ TEMP1 (PREAD)))
(NE (PUPRIN1 (CONCAT "SINCE " (CAR NE)
" IS THE ONLY NAME FOR " EXPRESSION
",
AT LEAST AS FAR AS PUP KNOWS RIGHT NOW, PUP ASSUMES THAT IS THE ONE
YOU WANT. AM I RIGHT?
USER: "))
(SETQ TEMP1 (COND ((MEMBER (PREAD)
(QUOTE (Y YES)))
(CAR NE)))))
(T (PUPRIN1 (CONCAT "I DON'T KNOW ANY NAMES FOR " EXPRESSION
", SO YOU'LL HAVE TO
TYPE A BRAND NEW NAME IN TO ME. "))
(TERPRI)
(SETQ TEMP1 NIL)))
(COND (TEMP1 (SETQ OLDNAME:TAG T)
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((EVAL NEW:NAME))
(T UNKNOWN:THING:ERROR))
TEMP1))
(T (PUPRIN1 "USER: ")
(SETQ TREAD (PREAD))
(SETQ TREAD (COND (TREAD)
((COLON:BACK (OUTVECTOR (OUTNIL (FLATTEN EXPRESSION)))))))
(COND ((NOT (OR (MEMBER TREAD PRIMITIVE:PROGRAMS:LIST)
(NUMBERP (CAR (LAST (COLON:BREAK TREAD))))))
(SETQ TREAD (PACK (TUPLE (@ TREAD)
:
(SETQ NEW:F:NUMBER (ADD1 NEW:F:NUMBER)))))))
(SET (COND ((ATOM NEW:NAME)
NEW:NAME)
((EVAL NEW:NAME))
(T UNKNOWN:THING:ERROR))
TREAD)
(SET TREAD TREAD)
(SETQ NAMED:EXPRESSION:LIST (CONS EXPRESSION NAMED:EXPRESSION:LIST))))))
COMMENTS ((COND ((NOT (ATOM NEW:NAME))
(SETQ NEW:NAME (CADR NEW:NAME)))
(T T))
(SETQ EV:NEW:NAME (COND ((ATOM NEW:NAME)
NEW:NAME)
(T (EVAL NEW:NAME)))))
PRE:REQUISITES ((VECTOR PUP STUDIED (VECTOR PLAUSIBLE NAMES FOR (@ EXPRESSION)))
(VECTOR AWARE USER (VECTOR PUP WANTS USER TO TYPE IN NAME FOR (@ EXPRESSION))))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR PUP AND USER ARE ABLE TO REFER TO (@ EXPRESSION)
AS
(@ NEW:NAME)
WHICH IS (EVAL NEW:NAME))))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR ABLE PUP (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR ABLE USER (VECTOR REFER ANY1 AS ANY2))
(VECTOR GET:NAME (@ ANY1)
(@ ANY2)))
((VECTOR NAMED EXPRESSION ANY1 ANY2)
(VECTOR GET:NAME (@ ANY1)
(@ ANY2))))
COMPLEXITY:VECTOR (.1 .3 .2 .5 .1))
(PUTPROPS GET:NEW:INFORMATION IDEN (((AND (EQUAL (CAR LI)
GET:NEW:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR GET:NEW:INFORMATION (CADR LI))))
BEING T
EXPLICIT:ARGS (NEW:INFO)
WHAT (TUPLE GET THE NEW PIECE OF INFORMATION AND CALL IT (@ NEW:INFO))
HOW (TUPLE ASK THE USER FOR NEW INFORMATION)
WHY (TUPLE WE NEED NEW INFORMATION; SEE ESPECIALLY SPEC:WHY)
WHEN ((T (COND (NEW:INFO:LIST -68)
(T 50))
(QUOTE (BECAUSE WE SHOULD GET NEW INFORMATION IFF THERE IS NONE IN EXISTENCE)))
)
META:CODE (PROG1 (COND ((ATOM NEW:INFO)
(SET NEW:INFO (INVECTOR (PREAD))))
(T (SET (EVAL NEW:INFO)
(INVECTOR (PREAD)))))
(SETQ NEW:INFO:LIST (CONS (EVAL NEW:INFO)
NEW:INFO:LIST))
(SETQ PUP:WANTED:LIST (CONS (CAR PUP:WANTS:LIST)
PUP:WANTED:LIST))
(SETQ PUP:WANTS:LIST (CDR PUP:WANTS:LIST)))
COMMENTS ((PUPRIN1 "
USER: ")) PRE:REQUISITES ((VECTOR AWARE USER (APPEND (QUOTE (VECTOR PUP WANTS))
(CDAR PUP:WANTS:LIST))))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE SPECIFICITY:CHECK:DEMON)
MAIN:EFFECTS (((VECTOR NEW INFO ANY1)
(VECTOR GET:NEW:INFORMATION (TUPLE QUOTE ANY1))))
COMPLEXITY:VECTOR (.1 .1 .1 .5 .1))
(PUTPROPS IS:OF:TYPE BEING T
EXPLICIT:ARGS (OBJECT SPECIAL:KNOWLEDGE)
EXPLICIT:ARGS:CHECK (MATCH (TUPLE COMMENT FRAG1)
SPECIAL:KNOWLEDGE)
WHAT (TUPLE SEE IF (@ OBJECT)
IS OF THE TYPE SPECIFIED. THE PARTICULAR TYPE IS DELINEATED BY THE SPECIAL KNOWLEDGE
(@ SPECIAL:KNOWLEDGE))
HOW (TUPLE USE (@ SPECIAL:KNOWLEDGE)
DETAILS TO SEE IF IT CONTAINS (@ OBJECT))
WHY (TUPLE WE MUST BE ABLE TO TEST AN OBJECT (@ OBJECT)
AND SEE IF IT BELONGS TO THE TYPE (@ SPECIAL:KNOWLEDGE))
META:CODE (PROGN (ASK:USER:ABOUT OBJECT))
COMPLEXITY:VECTOR (.35 .35 .35 .35 .1)
PREDICATE T
SPECIALIZATIONS (VECTOR (VECTOR DEFINITION
(VECTOR HOW DO WE KNOW WHEN THE 'IS:OF:TYPE' PREDICATE IS TRUE,
AND WHEN IT IS FALSE? PUP ASSUMES THAT USER WILL TYPE IN
A LOGICAL SENTENCE WHOSE TRUTH IS EQUIVALENT TO IT)
AFFECTS
(VECTOR CODE INVOLVING IS:OF:TYPE)
IS:OF:TYPE)))
(PUTPROPS JOINING:FUNCTION BEING T
EXPLICIT:ARGS ALIST
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE JOIN TOGETHER THE SET (@ ALIST)
OF RESULTS)
HOW (TUPLE USE A JOINING TYPE OF SIMPLE FUNCTION)
WHY (TUPLE WE HAVE SEVERAL TEMPORARY RESULTS, AND WE MUST COMBINE THEM TO PRODUCE A SINGLE
RESULT)
META:CODE (COMMENT DEPENDS UPON THE SPECIFIC FLAVOR OF JOINING REQUIRED. USUSALLY AND, OR,
XOR, SERIES, ... ETC.)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
GENERALIZATIONS (TUPLE RELATING:FUNCTION FUNCTION)
SPECIALIZATIONS (VECTOR (VECTOR PREDICATE (VECTOR WHEN WE TERMINATE THE LOOP)
AFFECTS
(VECTOR THE JOINING:FUNCTION ALGORITHM)
RESULTS LOOP:TERMINATION:LIST HOW
(INVECTOR (QUOTE (LAMBDA (PRED)
(COND ((MATCH (TUPLE DO UNTIL
FRAG1)
PRED)
(QUOTE AND))
((MATCH (TUPLE DO
REPEATEDLY
FRAG1)
PRED)
(QUOTE PROGN))
(T PRED)))))
JOINING:FUNCTION))
ALTERNATIVES (TUPLE SELECTING:FUNCTION ELIMINATING:FUNCTION)
PREDICATE T)
(PUTPROPS LIST:STRUCTURE BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE A LIST STRUCTURE ENTITY)
HOW (TUPLE A LIST OF ATOMS AND LIST STRUCTURES)
WHY (TUPLE ASSOCIATE THE PARTS OF THE LIST STRUCTURE)
META:CODE (STRUCTURE (CAR ATOM FRONT OF LIST:STRUCTURE)
(CDR LIST ALL BUT THE FRONT OF THE LIST:STRUCTURE))
COMPLEXITY:VECTOR (.2 .2 .2 .2 .1)
GENERALIZATIONS (TUPLE DATA:STRUCTURE)
DATA:STRUCTURE T)
(PUTPROPS MAKE:A:GUESS BEING T
IDEN (((MATCH (TUPLE YOUR GUESS)
LI)
(COND ((EQUAL (QUOTE POSSIBLE)
(CAR (COLON:BREAK ARG1)))
(VECTOR COMMENT MY GUESS FOR (@ ARG1)
IS
(LIST VECTOR @ ARG1)))
((EQUAL (QUOTE POSSIBLE)
(CAR COLON:BREAK ARG2))
ARG2))))
EXPLICIT:ARGS (POSS:OBJ)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE FIGURE OUT WHAT OUR 'GUESS' REFERS TO, AND POINT TO IT)
HOW (TUPLE EXAMINE OBJECTS BEGINNING POSSIBLE...)
WHY (TUPLE BECAUSE THE USER MAY REFER TO OBJECTS BY THEIR FEATURES, NOT THEIR NAMES)
META:CODE (PROGN (PUPRIN1 " BY GUESS I ASSUME YOU ARE REFERRING TO ")
(PUPRIN1 POSS:OBJ))
SPECIALIZATIONS (VECTOR (VECTOR ONETYPE
(VECTOR WE FIGURE OUT A GUESS AND PROGRAM IT IN; NO DECISION
TO MAKKE)
AFFECTS
(VECTOR THE MAKE:A:DECISION ALGORITHM)
RESULTS
(OR POSS:OBJ (EQUAL (QUOTE POSSIBLE)
(CAR (COLON:BREAK (SETQ POSS:OBJ ARG1))))
(EQUAL (QUOTE POSSIBLE)
(CAR (COLON:BREAK (SETQ POSS:OBJ ARG2)))))
MAKE:A:GUESS)))
(PUTPROPS MAKE:ENCODABLE BEING T
EXPLICIT:ARGS (B:CALL)
EXPLICIT:ARGS:CHECK T
WHAT (VECTOR TRY TO MAKE (@ B:CALL)
ENCODABLE)
HOW (TUPLE FIRST SEE IF IT ALREADY IS; IF NOT, TRY TO USE DOMAIN:DEPENDENT KNOWLEDGE)
WHY (TUPLE BECAUSE (@ B:CALL)
MUST EVENTUALLY GET ENCODED)
MAIN:EFFECTS (((VECTOR ENCODABLE SECTION ANY1)
(VECTOR MAKE:ENCODABLE (@ ANY1))))
META:CODE (OR (AND (ATOM B:CALL)
(GETP B:CALL ENCODABLE)
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ B:CALL)
TYPE OF (CAR (GETP B:CALL
GENERALIZATIONS))
IS
(INVECTOR (GETP B:CALL META:CODE)))
TYPE:OF:LIST)))
(AND (MATCH (VECTOR ANY1 TYPE OF ANY2 FRAG1)
B:CALL)
(SETQ ANY1:HOLD ANY1)
(SETQ ANY2:HOLD ANY2)
(COND ((MAKE:ENCODABLE ANY1))
((GETP ANY2:HOLD ENCODABLE)
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ ANY1:HOLD)
TYPE OF (@ ANY2:HOLD)
IS
(INVECTOR (GETP ANY2:HOLD
META:CODE)))))))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS MAKE:NEW:BEING BEING T
EXPLICIT:ARGS (FNAME)
EXPLICIT:ARGS:CHECK T
WHAT (VECTOR GIVE BIRTH TO THE NEW BEING (@ FNAME))
HOW (VECTOR FILL IN EACH PART OF A BEING, FOR THE BEING (@ FNAME))
WHY (VECTOR (@ FNAME)
MUST EXIST TO BE UNDERSTOOD)
MAIN:EFFECTS (((VECTOR IS BEING ANY1)
(VECTOR MAKE:NEW:BEING (@ ANY1))))
META:CODE (PROGN (SET FNAME FNAME)
(SETQ YY WRITE:PROGRAM)
(SETQ IS:BEING:LIST (CONS FNAME IS:BEING:LIST))
(SETQ TARGS (COND (FARGS (SETINTERSECTION FARGS FARGS))
((GETP BNAME EXPLICIT:ARGS))))
(SETQ BARGS (FIRSTN (LENGTH FARGS)
(GETP BNAME EXPLICIT:ARGS)))
(MAPC SET:OF:BEING:PARTS
(FUNCTION (LAMBDA (BP)
(COND ((GETP BNAME BP)
(PUT FNAME BP
(COND
(BARGS (SUBPAIR BARGS TARGS
(COPY (GETP BNAME BP))
T))
(T (GETP BNAME BP)))))))))
(PUT FNAME BEING T)
(PUT FNAME IDEN (SUBST FNAME BNAME (COPY (GETP FNAME IDEN))))
(ADD:IDEN FNAME)
(PUT FNAME MAIN:EFFECTS (SUBST FNAME BNAME (COPY (GETP FNAME MAIN:EFFECTS)))
)
(ADD:EFFECTS FNAME)
(PUT FNAME EXPLICIT:ARGS TARGS)
(PUT FNAME WHAT (VECTOR A SPECIALIZED BEING WHICH DOES (GETP FNAME WHAT)))
(PUT FNAME WHY (APPEND (GETP FNAME WHY)
(TUPLE AND (@ BNAME)
IS TOO GENERAL TO USE AS IT IS)))
(PUT FNAME META:CODE (COND ((LESSP (LENGTH CODE)
2)
(CAR CODE))
((NOT (LISTP (CAR CODE)))
CODE)
(T (CONS (QUOTE PROGN)
CODE))))
(COND ((LISTP (GETP FNAME EXPLICIT:ARGS:CHECK))
(PUPRIN1 (CONCAT "
IS " (GETP FNAME EXPLICIT:ARGS:CHECK)
" STILL THE PROPER EXPLICIT
ARGS CHECK FOR THE FUNCTION " FNAME "?
USER: "))
(COND ((MEMBER (PREAD)
(TUPLE NO N))
(PUPRIN1 "
WHAT IS THE CHECK, THEN? (I SUGGEST 'T')
USER: ")
(PUT FNAME EXPLICIT:ARGS:CHECK (OUTVECTOR
(LIST:TRANSLATE (INVECTOR (PREAD))
T)))))))
(PUT FNAME GENERALIZATIONS (CONS BNAME (GETP FNAME GENERALIZATIONS)))
(PUT FNAME AFFECTS (PROG (X)
(SETQ X (VECTOR))
(MAPC (FLATTEN CODE)
(FUNCTION
(LAMBDA (CC)
(COND
((GETP (CAR (COLON:BREAK CC))
BEING)
(SETQ
X
(NCONC1 X
(VECTOR (@ CC)
POSSIBLE
CALLED)))
(SETQ YY (CONS CC YY)))))))
(RETURN X)))
(PUT FNAME SPECIALIZATIONS NIL)
(PUT FNAME COMPLEXITY:VECTOR (VECTOR:AVERAGE YY))
(SEMI:COMPILE FNAME)
T)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS MESSAGE IDEN (((@ (AND (EQUAL (CAR LI)
MESSAGE)
(EQUAL (LENGTH LI)
2)))
(VECTOR MESSAGE (CADR LI)))
((@ (MATCH (TUPLE MAKE USER AWARE THAT FRAG1)
LI))
(VECTOR MESSAGE (INVECTOR FRAG1)))
((MATCH (TUPLE TELL ME FRAG1)
LI)
(VECTOR PRINT (VECTOR COMMENT I MUST TELL YOU (INVECTOR (INCOMMENT
(OUTVECTOR (TRANSLATE
(INVECTOR FRAG1)
T))))))))
BEING T
EXPLICIT:ARGS (M)
WHAT (TUPLE GIVE THE USER THE MESSAGE (@ M))
HOW (TUPLE THE USER WILL PREAD THE MESSAGE (@ M)
THAT PUP TYPES OUT)
WHY (TUPLE SO THAT THE USER MAY ASSIMILATE THE INFORMATION IN THE MESSAGE (@ M))
WHEN (((MEMBER M AWARE:USER:LIST)
-201
(QUOTE (BECAUSE THE USER NEVER FORGETS))))
META:CODE (PROGN (TERPRI)
(PUPRIN1 "PUP: ")
(PUPRINT (OUTVECTOR M))
(TERPRI)
(SETQ AWARE:USER:LIST (CONS M AWARE:USER:LIST))
(SETQ FRINGE:CONCIOUS:LIST (LIST M (CAR FRINGE:CONCIOUS:LIST)))
(SETQ LASTRESPONDER (QUOTE PUP))
(SETQ READ:USER:LIST (CONS M READ:USER:LIST)))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR PREAD USER ANY1)
(VECTOR MESSAGE (@ ANY1)))
((VECTOR AWARE USER ANY1)
(VECTOR MESSAGE (@ ANY1))))
MINOR:EFFECTS ((QUOTE (LASTRESPONDER PUP)))
COMPLEXITY:VECTOR (0.0 .1 .9 .7 .1)
GENERALIZATIONS (COMMUNICATE I/O)
SPECIALIZATIONS (RESPOND QUERY))
(PUTPROPS METRICAL:CONCEPT:FORMATION BEING T
META:CODE (PROGN (PARTITION:A:DOMAIN)
(ORDER PARTITION)
(METRIZE ORDER))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS MODIFY:STRUCTURE BEING T
EXPLICIT:ARGS (S)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE MODIFY THE STRUCTURE CONTAINING (@ S)
AS AN ELEMENT)
HOW (TUPLE BY SOME OF THESE: INSERTING, DELETING, ALTERING AN ELEMENT OR TWO)
WHY (TUPLE BECAUSE THE GIST OF CONCEPT FORMATION IS MODIFYING THE STRUCTURE WHICH
REPRESENTS A DESCRIPTION OF A CONCEPT)
META:CODE (VECTOR THIS DEPENDS ON WHAT THE USER WANTS DONE TO THE STRUCTURE)
COMPLEXITY:VECTOR (.7 .7 .7 .7 .5)
GENERALIZATIONS (TUPLE MODIFY)
SPECIALIZATIONS (VECTOR (VECTOR SUBSETOF (VECTOR CONDITIONAL:INSERTION
CONDITIONAL:DELETION COMPLEX:ALTERATION)
AFFECTS
(VECTOR THE MODIFY:STRUCTURE ALGORITHM)
COMMENT
(COMMENT CONDITIONAL:INSERTION MEANS WE WILL INSERT AN
ELEMENT LIKE THE ARG1 INTO THE SUITABLE OUTER
LIST STRUCTURE; CONDITIONAL:DELETION IS SIMILAR;
BOTH OF THESE ARE DONE ONLY WHEN SOME
YET-TO-BE-SPECIFIED CONDITION IS TRUE. THE FINAL
CHOICE, COMPLEX:MODIFICATION, MEANS THAT SOME
SUB-PARTS OF THE ARG1 ITSELF ARE TO BE INSERTED,
DELETED, OR CHANGED.)
MODIFY:STRUCTURE))
ALTERNATIVES (TUPLE REPLACE:STRUCTURE DELETE:ENTIRE:STRUCTURE))
(PUTPROPS OBTAIN:USABLE:INFORMATION IDEN (((AND (EQUAL (CAR LI)
OBTAIN:USABLE:INFORMATION)
(EQUAL (LENGTH LI)
2))
(VECTOR OBTAIN:USABLE:INFORMATION (CADR LI))))
BEING T
EXPLICIT:ARGS (U)
WHAT (TUPLE OBTAIN SOME INFORMATION WHICH CAN BE USED)
HOW (TUPLE OBTAIN NEW FACTS ABOUT OLD INFORMATION, OR OBTAIN TOTALLY NEW
INFORMATION)
WHY (TUPLE PUP HAS NO MORE INFORMATION THAT IT CAN USE TO PROGRESS)
WHEN ((T -10 (TUPLE SINCE THIS IS AN EXPONENTIALLY-GROWING, BAD THING TO DO IN
GENERAL))
(NEW:INFO:LIST 111
(QUOTE (BECAUSE WE SHOULD WORK ON UNASSIMILATED NEW
INFORMATION IF THERE IS ANY))))
META:CODE (PROGN (SETQ BECAUSE
(QUOTE (VECTOR WE CAN ONLY TRY TO OBTAIN USABLE
INFORMATION IN ONE WAY AT A TIME)))
(CHOOSE:FROM (QUOTE ((TRANSLATE U)
(GET:NEW:INFORMATION U)
(ANALYZE:IMPLICATIONS U)
(EXTRACT:RELEVANT:SUBSET U)))))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR NEW INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1)))
((VECTOR USABLE INFO ANY1)
(VECTOR OBTAIN:USABLE:INFORMATION (@ ANY1))))
AFFECTS (QUOTE ((CHOOSE:FROM CALLED)
(TRANSLATE POSSIBLE:CALLED)
(GET:NEW:INFORMATION POSSIBLE:CALLED)
(ANALYZE:IMPLICATIONS POSSIBLE:CALLED)
(EXTRACT:RELEVANT:SUBSET POSSIBLE:CALLED)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS PARTITION:A:DOMAIN BEING T
EXPLICIT:ARGS:CHECK T
META:CODE (PROGN (COMMENT WE SHOULD NEVER REALLY BE HERE, SINCE THIS IS ALWAYS DONE BY A
COLLECTION OF THE THREE METHODS OF PARTITIONING DISCUSSED IN
THE 'SPECIALIZATIONS' SECTION)
(SETQ PARTITIONED:DOMAIN:LIST T))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR (VECTOR BOOLEAN (VECTOR PARTITION MAY BE ONLY PARTIAL)
AFFECTS
(VECTOR WHETHER AN ELEMENT OF THE DOMAIN MAY BELONG TO
ZERO CLASSES)
WHEN
(VECTOR BEFORE ANY TERMINATION:OF:IDENTIFICATION
ROUTINES ARE FINALIZED)
PARTITION:A:DOMAIN)
(VECTOR BOOLEAN (VECTOR PARTITION MAY BE ONLY WEAK)
AFFECTS
(VECTOR WHETHER AN ELEMENT OF THE DOMAIN MAY BELONG TO
MANY CLASSES)
WHEN
(VECTOR BEFORE ANY TERMINATION:OF:IDENTIFICATION
ROUTINES ARE FINALIZED)
PARTITION:A:DOMAIN)
(VECTOR SOMEOF (VECTOR PARTITION:BY:TAKE:ELE:AND:CLASS
PARTITION:BY:TAKE:CLASS:GET:ELE
PARTITION:BY:TAKE:ELE:GET:CLASS)
AFFECTS
(VECTOR THE PARTITION:A:DOMAIN ALGORITHM)
PARTITION:A:DOMAIN))
IDEN (((MATCH (TUPLE PARTITION A DOMAIN)
LI)
(VECTOR PARTITION:A:DOMAIN))
((MATCH (TUPLE DIVIDE A DOMAIN UP)
LI)
(VECTOR PARTITION:A:DOMAIN)))
WHAT (TUPLE DIVIDE A DOMAIN INTO SUBDOMAINS; USUALLY THESE WILL BE DISJOINT, AND THEIR
UNION WILL BE THE ENTIRE DOMAIN)
HOW (TUPLE BY BUILDING UP THE PARTITION GRADUALLY, BY ADDING TO OUR KNOWLEDGE OF THE
PARTITION ONE PAIR AT A TIME; HERE A PAIR IS <ELEMENT, CLASS:NAME>)
WHY (TUPLE BECAUSE PUP MUST ENCODE A FUNCTION WHICH PARTITIONS A DOMAIN INTO CLASSES)
MAIN:EFFECTS (((VECTOR PARTITIONED DOMAIN)
(VECTOR PARTITION:A:DOMAIN)))
WHEN ((PARTITIONED:DOMAIN:LIST -100 (TUPLE BECAUSE WE ALREADY HAVE PARTITIONED DOMAIN))
((NULL PARTITIONED:DOMAIN:LIST)
20
(TUPLE BECAUSE PUP HAS NOT YET PARTITIONED DOMAIN, SO IT IS PLAUSIBLE TO DO IT
NOW)))
DEMONS (TUPLE FRINGE:OF:CONCIOUSNESS:DEMON)
GENERALIZATIONS (TUPLE MAP BUILD:FUNCTION)
ALTERNATIVES (TUPLE DIVIDE:UP DISCRETIZE))
(PUTPROPS PARTITION:BY:TAKE:CLASS:GET:ELE BEING T
EXPLICIT:ARGS:CHECK T
META:CODE (PROGN (TAKE:HOLD:OF NAME:OF:CLASS)
(GET:HOLD:OF ELEMENT)
(MODIFY:STRUCTURE NAME:OF:CLASS))
GENERALIZATIONS (TUPLE PARTITION:A:DOMAIN)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS PARTITION:BY:TAKE:ELE:AND:CLASS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE BUILD A PARTITION BY REPEATEDLY TAKING IN ELEMENTS AND THEIR
ASSOCIATED CLASS NAMES)
HOW (TUPLE PREAD IN PAIRS OF ELEMENT:CLASS)
WHY (TUPLE PARTITION IS DEFINED AS A SET OF ORDERED PAIRS)
META:CODE (PROGN (TAKE:HOLD:OF ELEMENT)
(TAKE:HOLD:OF NAME:OF:CLASS)
(MODIFY:STRUCTURE NAME:OF:CLASS))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS PARTITION:BY:TAKE:ELE:GET:CLASS BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE BUILD A PARTITION BY REPEATEDLY TAKING IN ELEMENT AND
DETERMINING THE CLASS IT BELONGS TO)
HOW (TUPLE PREAD IN ELEMENT, DEDUCE ITS CLASS)
WHY (TUPLE TO SHOW THAT THE PARTITIONING IS BEING DONE CORRECTLY)
META:CODE (PROGN (TAKE:HOLD:OF ELEMENT)
(GET:HOLD:OF NAME:OF:CLASS)
(MODIFY:STRUCTURE NAME:OF:CLASS))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS PROBABILITY=0:# BEING T
EXPLICIT:ARGS (OBJECT WORLD)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SEE IF (@ OBJECT)
, WHICH MUST OCCUR WITH PROBABILITY = 0 (TUPLE I.E., NEVER)
CONTRADICTS THE PART OF THE WORLD SPECIFIED BY (@ WORLD))
HOW (TUPLE SINCE (@ OBJECT)
SHOULD NEVER OCCUR IN THE WORLD, IN PARTICULAR WE WILL HAVE A CONTRADICTION IF
IT OCCURS IN (@ WORLD)
;I.E., WE CHECK TO MAKE SURE THAT (@ OBJECT)
IS NOT A MEMBER OF (@ WORLD))
META:CODE (PROGN (COMMENT SINCE ARG1 SHOULD NEVER OCCUR, WE HAVE A CONTRADICTION IF IT IS A
MEMBER OF ARG2)
(MEMBER ARG1 ARG2))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
PREDICATE T
ENCODABLE T)
(PUTPROPS PROBABILITY=1:# BEING T
EXPLICIT:ARGS (OBJECT WORLD)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SEE IF (@ OBJECT)
,WHICH MUST OCCUR WITH PROBABILITY = 1, CONTRADICTS THE PART OF THE WORLD
SPECIFIED BY (@ WORLD))
HOW (TUPLE SINCE (@ OBJECT)
MUST OCCUR (TUPLE PROB. = 1)
WE SHALL CHECK TO SEE THAT (@ OBJECT)
IS A MEMBER OF (@ WORLD))
META:CODE (PROGN (COMMENT ARG1 OCCURS WITH PROBABILITY 1, SO IT HAD BETTER BE IN ARG2, THE
RELEVANT PIECE OF THE WORLD)
(NOT (MEMBER ARG1 ARG2)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
PREDICATE T
ENCODABLE T)
(PUTPROPS PROBABILITY>0&<1:# BEING T
EXPLICIT:ARGS (OBJECT WORLD)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SEE IF THE OBJECT (@ OBJECT)
CONTRADICTS
(@ WORLD)
%. SINCE THE FORMER HAS A PROBABILITY STRICTLY > 0, AND STRICTLY < 1, WE
CANNOT DO THIS EASILY)
HOW (TUPLE SINCE (@ OBJECT)
HAS A PROBABILITY STRICTLY BETWEEN 0 AND 1 OF OCCURRING IN (@ WORLD)
,THERE IS NO EASY WAY TO TEST FOR CONTRADICTION; THUS WE SIMPLY ALWAYS SAY
THAT THERE IS NONE.)
META:CODE (PROGN (COMMENT WE MAY OR MAY NOT HAVE ARG1 IN ARG2; EITHER CASE IS ALLOWABLE;
SO WE NEVER HAVE A CONTRADICTION)
NIL)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
PREDICATE T
ENCODABLE T)
(PUTPROPS PROPOSE:PLAUSIBLE:NAMES BEING T
IDEN (((AND (EQUAL (CAR LI)
PROPOSE:PLAUSIBLE:NAMES)
(EQUAL (LENGTH LI)
2))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI)))
((MATCH (QUOTE (PROPOSE PLAUSIBLE NAMES FOR ANY1))
LI)
(VECTOR PROPOSE:PLAUSIBLE:NAMES (CADR LI))))
IMPLICIT:ARGS (EXPRES2 NEW:EXPRES MSG)
EXPLICIT:ARGS (EXPRES)
EXPLICIT:ARGS:CHECK (COND ((ATOM EXPRES)
(SETQ NEW:EXPRES (COLON:BREAK EXPRES)))
(T (SETQ NEW:EXPRES
(PROG (TEMP1)
(MAPC EXPRES (FUNCTION
(LAMBDA (ZZ)
(SETQ TEMP1
(APPEND
TEMP1
(COLON:BREAK
ZZ))))))
(RETURN TEMP1)))))
WHAT (TUPLE PROPOSE PLAUSIBLE NAMES FOR (@ EXPRES))
HOW (TUPLE USE PARLOR PSYCHOLOGY TO EXTRACT MNEMONIC CONTRACTIONS OF (@ EXPRES))
WHY (TUPLE AID THE USER OR PUP IN CHOOSING A EXPRES FOR THE OBJECT (@ EXPRES))
MAIN:EFFECTS (((VECTOR PLAUSIBLE NAMES (VECTOR FOR ANY1 HAVE BEEN STUDIED))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR PLAUSIBLE NAMES FOR ANY1))
(VECTOR PROPOSE:PLAUSIBLE:NAMES (@ ANY1))))
WHEN ((T (COND ((MEMBER (TUPLE PLAUSIBLE NAMES FOR (@ EXPRES))
PUP:STUDIED:LIST)
-99)
(T 33))
(QUOTE (BECAUSE WE SHOULDNT WASTE OUTQUOTE NEW:EXPRES))))
META:CODE (PROG (P)
(SETQ EXPRES2 (OUTVECTOR (OUTQUOTE NEW:EXPRES)))
(SETQ P (MAPCAR (LIST (INITIALS EXPRES2)
(MAIN:WORDS EXPRES2)
(FIRST:FEW (INITIALS EXPRES2))
(FIRST:FEW (INITIALS (MAIN:WORDS EXPRES2)))
(LIST (PACK (INITIALS EXPRES2)))
(LIST (PACK (FIRST:FEW (INITIALS EXPRES2)))))
(QUOTE COLON:BACK)))
(SETQ P (SETDIFFERENCE P KNOWN:NAMES))
(SETQ P (INTERSECTION P P))
(SETQ MSG (VECTOR (@ P)
IS THE SET OF PLAUSIBLE NAMES OF (@ EXPRES2)
WHICH IS AN EXPANSION OF (@ EXPRES)))
(SETQ PLAUSIBLE:NAMES:LIST (CONS (VECTOR FOR (@ EXPRES)
HAVE BEEN STUDIED)
PLAUSIBLE:NAMES:LIST))
(SETQ PUP:STUDIED:LIST (CONS (VECTOR PLAUSIBLE NAMES FOR
(@ EXPRES))
PUP:STUDIED:LIST))
(RETURN P))
POST:REQUISITES ((VECTOR AWARE USER (INVECTOR MSG)))
DEMONS (TUPLE FRINGE:OF:CONCIOUSNESS:DEMON PSYCHOLOGY:DEMON)
COMPLEXITY:VECTOR (.1 .2 .3 .5 .1))
(PUTPROPS RECOGNIZE:# BEING T
IDEN (((@ (MATCH (TUPLE ANY ANY1 IN ANY2 IS FRAG1)
LI))
(VECTOR DO UNTIL (VECTOR FORSOME (@ ANY1)
IN
(@ ANY2)
(TRANSLATE (APPEND (LIST VECTOR ANY1 IS)
FRAG1)
T))))
((@ (MATCH (TUPLE ANY1 IS INCOMPATIBLE WITH ANY2)
LI))
(VECTOR RECOGNIZE:# (@ ANY1)
(@ ANY2))))
PREDICATE T
EXPLICIT:ARGS (OBJECT WORLD)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE SEE IF (@ OBJECT)
IS IN CONTRADICTION TO THE COLLECTION (@ WORLD))
HOW (TUPLE SEE HOW A (@ OBJECT)
TYPE OF OBJECT CAN BE CONTRADICTORY, THEN EXAMINE THE RELATIONSHIP BETWEEN
(@ OBJECT)
AND
(@ WORLD))
META:CODE (PROGN (DETERMINE:CONTRADICTION:CRITERIA)
(CHECK CONTRADICTION:CRITERIA OBJECT WORLD))
COMPLEXITY:VECTOR (.4 .4 .4 .4 .1)
SPECIALIZATIONS (VECTOR (VECTOR SOMEOF (VECTOR PROBABILITY=1:# PROBABILITY=0:#
PROBABILITY>0&<1:#)
AFFECTS
(VECTOR THE RECOGNIZE:# ALGORITHM)
COMMENT
(COMMENT
THE FOLLOWING ARE THE 'HOW' PARTS OF THE ABOVE CHOICES:
(QUOTE (PROGN (DETERMINE:ARG:VALUE CHOICE)
(DETERMINE:ARG2:VALUE CHOICE)
(MAPCAR (CDAR (CDDADR D))
(FUNCTION
(LAMBDA
(CHOI)
(MAP2C (TUPLE ARG1 ARG2 ARG3 ARG4
ARG5 ARG6)
(GETP CHOI EXPLICIT:ARGS)
(FUNCTION
(LAMBDA
(ARGK ARGU)
(SET ARGU (EVAL ARGK)))))
(LIST CHOI (EVAL (GETP CHOI HOW)))))
))))
RECOGNIZE:#)))
(PUTPROPS RECOGNIZE:ARGS BEING T
IDEN (((Z@ (AND (MATCH (TUPLE A R G ANY1)
(UNPACK (CAR LI)))
(EQUAL LI (LIST (PACK (TUPLE A R G (@ ANY1)))))))
(CONS VECTOR LI)))
EXPLICIT:ARGS:CHECK T
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS RECOGNIZE:CAR BEING T
IDEN (((MATCH (TUPLE THE FRONT PART OF ANY1 FRAG1)
LI)
(APPEND (VECTOR CAR)
(COND ((ATOM (SETQ TTR (TRANSLATE (LIST VECTOR ANY1)
T)))
(LIST TTR))
(T (CDR TTR)))
(COND (FRAG1 (CDR (TRANSLATE (INVECTOR FRAG1)
T)))))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS RECOGNIZE:CONDITIONAL BEING T
IDEN (((@ (@ (@ (MATCH (TUPLE IF FRAG1 THEN ANY1 ELSE ANY2)
LI))))
(PROGN (SETQ SA1 ANY1)
(SETQ SA2 ANY2)
(VECTOR COND (VECTOR (TRANSLATE (INVECTOR FRAG1)
T)
(CADR (TRANSLATE (LIST VECTOR SA1)
T)))
(VECTOR T (CADR (TRANSLATE (LIST VECTOR SA2)
T))))))))
(PUTPROPS RECOGNIZE:CONJUNCTION BEING T
IDEN (((@ (@ (AND (SETQ PART2 (MEMBER (QUOTE AND)
LI))
(SETQ PART1 (LDIFF LI PART2)))))
(APPEND (VECTOR AND (TRANSLATE (INVECTOR PART1)
T))
(COND ((EQUAL (CADR (SETQ FXC (TRANSLATE (INVECTOR (CDR PART2))
T)))
(QUOTE AND))
(CDDR FXC))
(T (LIST FXC)))))))
(PUTPROPS RECOGNIZE:EQUALITY BEING T
IDEN (((@ (AND (SETQ PART2 (MEMBER EQUALS LI))
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDR PART2))
T)))
((@ (AND (SETQ PART2 (MEMBER ISNT LI))
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR NOT (VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDR PART2))
T))))
((@ (AND (SETQ PART2 (MEMBER DOESNT LI))
(EQUAL (CADR PART2)
EQUAL)
(SETQ PART1 (LDIFF LI PART2))))
(VECTOR EQUAL (TRANSLATE (INVECTOR PART1)
T)
(TRANSLATE (INVECTOR (CDDR PART2))
T))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS RECOGNIZE:FUNCTION:RETURNS BEING T
IDEN (((MATCH (TUPLE ANY1 SUCCEEDED)
LI)
(TRANSLATE (VECTOR THE RESULT OF (@ ANY1)
ISNT NIL)
T))
((MATCH (TUPLE THE RESULT OF ANY1)
LI)
(COND ((CADR (SASSOC LI RESULT:BINDING:LIST)))
((SETQ XTEMP (SASSOC ANY1 (OUTVECTOR FN:CALL:LIST)))
(INVECTOR XTEMP))
((LISTP ANY1)
(INVECTOR ANY1))
((LIST VECTOR ANY1))))
((MATCH (TUPLE THE ANY1 SUCCEEDED)
LI)
(TRANSLATE (VECTOR THE RESULT OF (@ ANY1)
ISNT NIL)
T))
((AND (MATCH (TUPLE R E S U L T : FRAG1)
(UNPACK (CAR LI)))
(EQUAL (LENGTH LI)
1))
(CAR LI)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS RECOGNIZE:INCLUSION BEING T
IDEN (((@ (@ (AND (SETQ PART2 (MEMBER (QUOTE IN)
LI))
(SETQ PART1 (LDIFF LI PART2))
(SETQ NEGAT (CAR (LAST PART1)))
(MEMBER NEGAT (TUPLE IS ISNT))
(NOT (EQUAL (QUOTE WHICH)
(CADR (REVERSE PART1)))))))
(VECTOR (COND ((EQUAL NEGAT (QUOTE IS))
@)
(T (QUOTE NOT)))
(VECTOR MEMBER (TRANSLATE (INVECTOR (PULLOUT NEGAT PART1))
T)
(TRANSLATE (INVECTOR (CDR PART2))
T)))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS RECOGNIZE:LITERALS BEING T
IDEN (((Z@ (OR (AND (MATCH (TUPLE ANY1)
LI)
(OR (NUMBERP ANY1)
(MEMBER ANY1 PRIMITIVE:VARS:LIST)
(MEMBER ANY1 (FLATTEN TRUE:FN:CALL:LIST))
(PROGN (PUPRINT (TUPLE IS (@ ANY1)
A LITERAL CONSTANT
(TUPLE WHOSE VALUE SHOULD BE ITSELF)
(TUPLE REPLY YES OR NO, PLEASE)
USER...))
(MEMBER (PREAD)
(QUOTE (YES Y PROBABLY))))))
(AND (GREATERP (LENGTH LI)
1)
(SETQ ANY1 (TRANSLATE (COLON:BACK LI)
T)))))
(COND ((ATOM ANY1)
(SETQ GLOBAL:INITIALIZATION:LIST (CONS (LIST (QUOTE SETQQ)
ANY1 ANY1)
GLOBAL:INITIALIZATION:LIST))
(SET ANY1 ANY1))
(T ANY1)))
((@ (AND (EQUAL (LENGTH LI)
1)
(MEMBER (CAR LI)
PRIMITIVE:VARS:LIST)))
(CAR LI)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
POST:REQUISITES ((VECTOR GLOBAL INITIALIZATION ANY1)))
(PUTPROPS RECOGNIZE:SET:RELATIONS BEING T
IDEN (((MATCH (TUPLE ANY1 WHICH IS NOT IN ANY2)
LI)
(PROGN (SETQ SANY2 ANY2)
(VECTOR SETDIFFERENCE (TRANSLATE (LIST VECTOR ANY1)
T)
(TRANSLATE (LIST VECTOR SANY2)
T))))
((MATCH (TUPLE ANY1 WHICH IS IN ANY2)
LI)
(PROGN (SETQ SANY2 ANY2)
(VECTOR SETINTERSECTION (TRANSLATE (LIST VECTOR ANY1)
T)
(TRANSLATE (LIST VECTOR SANY2)
T))))
((MATCH (TUPLE ANY1 WHICH IS NOT IN ANY OF FRAG1)
LI)
(PROGN (SETQ HFRAG1 (PULLOUT (QUOTE OR)
FRAG1))
(VECTOR SETDIFFERENCE (TRANSLATE (LIST VECTOR ANY1)
T)
(APPEND (VECTOR APPEND)
(MAPCAR HFRAG1 (FUNCTION (LAMBDA (SA2)
(TRANSLATE
(LIST VECTOR SA2)
T)))))))))
IMPLICIT:ARGS NIL
EXPLICIT:ARGS NIL
EXPLICIT:ARGS:CHECK NIL
NLAMBDA NIL
NON:EVAL:ARGS NIL
WHAT NIL
HOW NIL
WHY NIL
MAIN:EFFECTS NIL
MINOR:EFFECTS NIL
WHEN NIL
META:CODE NIL
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
DEMONS NIL
AFFECTS NIL
COMPLEXITY:VECTOR NIL
GENERALIZATIONS NIL
SPECIALIZATIONS NIL
ALTERNATIVES NIL
PREDICATE NIL
DATA:STRUCTURE NIL
ENCODABLE NIL
INHIBIT:CURRENT:DEMONS NIL
FORM:CHANGING NIL)
(PUTPROPS RECOGNIZE:SOME:MEMBER BEING T
IDEN (((MATCH (TUPLE SOMETHING IN FRAG1)
LI)
(VECTOR CAR (TRANSLATE (INVECTOR FRAG1)
T)))))
(PUTPROPS REINVESTIGATE:DECISION BEING T
IDEN (((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ ANY1)))))
IMPLICIT:ARGS (D1)
EXPLICIT:ARGS (D)
EXPLICIT:ARGS:CHECK (OR (MEMBER D DEFERRED:DECISION:LIST)
(EQUAL (CADDDR D)
(VECTOR BECAUSE OF DIRECT COMMAND)))
WHAT (VECTOR RESOLVE THE DECISION (CADR D)
BECAUSE
(CADDDR D)
IS NOW TRUE; FIRST TRY TO DEFER IT A LITTLE LONGER)
HOW (VECTOR TRY TO DEFER (CADDR D)
;ELSE TRY TO RESOLVE IT WITH PRESENT KNOWLEDGE ;ELSE ASK THE USER TO
RESOLVE IT)
WHY (VECTOR AS FAR AS WE KNOW AT THIS INSTANT, THE DECISION (CADDR D)
CANNOT BE DEFERRED ANY LONGER)
MAIN:EFFECTS (((VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ D)))))
META:CODE (PROGN (SETQ DEFERRED:DECISION:LIST (PULLOUT D DEFERRED:DECISION:LIST))
(SETQ UNDEFERRED:DECISION:LIST (CONS (CADR D)
UNDEFERRED:DECISION:LIST))
(DEFER:DECISION (CADR D)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
INHIBIT:CURRENT:DEMONS T)
(PUTPROPS REPEATEDLY BEING T
EXPLICIT:ARGS (ACT1 ACT2 ACT3 ACT4)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE DO ACTIONS OVER AND OVER)
HOW (TUPLE CONVERT THE SINGLE FUNCTION CALL INTO AN INFINITE ITERATIVE LOOP)
WHY (TUPLE THIS IS EASIER, SURER, AND OFTEN FASTER THAN RECURSION)
META:CODE (PROGN (VECTOR SEE THE FORM:CHANGING SECTION)
(SETQ F1 (APPEND (TUPLE REPEATEDLY)
ACT1 ACT2 ACT3 ACT4))
(EVAL (GETP REPEATEDLY FORM:CHANGING)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
FORM:CHANGING (PROGN (SETQ F1 (APPEND (TUPLE PROG NIL (SETQ TEMPL (COLON:BACK
(TUPLE LABEL (SETQ LABEL:COUNTER
(ADD1
LABEL:COUNTER)))))
)
(CONS (PROG1 (SETQ C1 (GETCODE (CADR F1)
FNAME 0))
(COND ((NUMBERP (CAR (LAST (COLON:BREAK
C1))))
(SETQ
FN:CALL:LIST
(CONS (INVECTOR (CONS C1
(CDDR F1)))
FN:CALL:LIST)))))
(GETCODE (CDDR F1)
FNAME 1))
(TUPLE (LIST GO TEMPL)
(TUPLE COMMENT INFINITE LOOP IN THIS PROG))))
(SETQ CODING:WARNING:LIST (CONS (TUPLE 101 VECTOR INFINITE LOOP IN
(@ FNAME)
FROM
(@ TEMPL)
TO
(LIST VECTOR GO TEMPL))
CODING:WARNING:LIST))
F1))
(PUTPROPS RESOLVE:DECISION BEING T
IDEN (((AND (EQUAL (CAR LI)
RESOLVE:DECISION)
(EQUAL (LENGTH LI)
2))
(VECTOR RESOLVE:DECISION (CADR LI)))
((MATCH (QUOTE (RESOLVE THE DECISION ANY1))
LI)
(VECTOR RESOLVE:DECISION (VECTOR (VECTOR BECAUSE OF DIRECT COMMAND)
(@ ANY1)))))
IMPLICIT:ARGS (D1 ENT2 ENT1 TRESULT NEWPIECE)
EXPLICIT:ARGS (D STAG)
EXPLICIT:ARGS:CHECK T
WHAT (VECTOR RESOLVE THE DECISION (CADR D)
BECAUSE
(CADDDR D)
IS NOW TRUE)
HOW (VECTOR TRY TO RESOLVE (CADR D)
WITH PRESENT KNOWLEDGE; IF THAT FAILS, ASK THE USER ABOUT IT)
WHY (VECTOR AS FAR AS WE KNOW AT THIS INSTANT, THE DECISION (CADR D)
CANNOT BE DEFERRED ANY LONGER)
MAIN:EFFECTS (((VECTOR RESOLVED DECISION ANY1)
(VECTOR RESOLVE:DECISION (VECTOR (@ D)
SINCE
(VECTOR DIRECT COMMAND)))))
META:CODE (COND ((MEMBER (CADR D)
RESOLVED:DECISION:LIST)
T)
(T (SETQ RESOLVED:DECISION:LIST (CONS (VECTOR (CADR D)
IS RESOLVED AS
(INVECTOR (ASK:USER:ABOUT
D)))
RESOLVED:DECISION:LIST))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
INHIBIT:CURRENT:DEMONS T)
(PUTPROPS SATISFY IDEN (((AND (EQUAL (CAR LI)
SATISFY)
(EQUAL (LENGTH LI)
2))
(VECTOR SATISFY (TRANSLATE (CADR LI)
T))))
IMPLICIT:ARGS (TEMP:LIST EV:G)
EXPLICIT:ARGS (G FORCE:SAT)
WHAT (TUPLE SATISFY THE SIMPLE SUBGOAL (@ G))
HOW (TUPLE PASS CONTROL TO THE SIMPLEST SUFFICIENT BEING)
WHY (TUPLE (@ G)
IS A REQUISITE TO BE SATISFIED)
META:CODE (COND
((AND (MEMBER EV:G (EVAL (SETQ TEMP:LIST (COLON:BACK (COPY (LIST (CADR G)
(CADDR G)
(QUOTE LIST)))))))
(NOT FORCE:SAT)))
(T
(PROG
(B:LIST)
(MAPC EFFECTS:TABLE (FUNCTION (LAMBDA (E1)
(COND ((MATCH (CAR E1)
G)
(SETQ B:LIST
(CONS (EVAL (CADR E1))
B:LIST)))))))
(SETQ BECAUSE (VECTOR WE CALL THE SIMPLEST BEING WHICH CAN BRING ABOUT THE EFFECT
(@ G)))
(COND
(B:LIST
(RETURN
(PROG (CB:LIST POS:B)
(SETQ CB:LIST (COPY (MAPCAR B:LIST (QUOTE CDR))))
(SETQ CB:LIST (INTERSECTION CB:LIST CB:LIST))
(SORT CB:LIST A:BEING:ORDER)
LABEL5
(SETQ POS:B (CAR CB:LIST))
(EVAL POS:B)
(COND
((MEMBER EV:G (EVAL TEMP:LIST))
(RETURN (SETQ PUP:SATISFIED:LIST (CONS G PUP:SATISFIED:LIST))))
((CDR CB:LIST)
(SETQ CB:LIST (CDR CB:LIST))
(GO LABEL5))
(T (PUPRIN1 "
WARNING: SATISFY IS SHAKING ITS HEAD ABOUT THIS ONE:")
(PUPRIN1 G)
(RETURN NIL))))))
(T (RETURN NIL))))))
COMMENTS ((SETQ G (EVAL G))
(SETQ EV:G (EVAL (CADDDR G))))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR PUP SATISFIED ANY1)
(VECTOR SATISFY (@ ANY1))))
AFFECTS (APPEND (MAPCAR (PROG (B:LIST)
(MAPC EFFECTS:TABLE (FUNCTION (LAMBDA
(E1)
(COND ((MATCH (CAR E1)
G)
(SETQ
B:LIST
(CONS (EVAL (CADR E1))
B:LIST)))))))
(RETURN B:LIST))
(FUNCTION (LAMBDA (Y)
(COND (Y (CONS Y (QUOTE (POSSIBLE:CALLED))))))))
(QUOTE ((TRY:BEING CALLED)
(SORT CALLED)
(A:BEING:ORDER CALLED))))
COMPLEXITY:VECTOR (0.0 .3 .2 .4 .1)
GENERALIZATIONS (SERVE)
SPECIALIZATIONS (TRY:BEING)
ALTERNATIVES (WRITE:PROGRAM ADAPT:PRECONCEIVED:FUNCTION)
BEING T
INHIBIT:CURRENT:DEMONS T)
(PUTPROPS SCENE BEING T
META:CODE (STRUCTURE (OBJECTS SET O)
(CLASS:NAME NAME N)
(STATIC RELATIONS S BETWEEN OBJECTS)
(DYNAMIC RELATIONS D BETWEEN OBJECTS))
IDEN (((EQUAL LI (LIST SCENE))
(VECTOR SCENE)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
DATA:STRUCTURE T)
(PUTPROPS SEARCH BEING T
EXPLICIT:ARGS (GOAL SPACE)
EXPLICIT:ARGS:CHECK SPACE
WHAT (TUPLE SEARCH THROUGH A KNOWN, FINITE SPACE (@ SPACE)
FOR AN ELEMENT SATISFYING THE GOAL (@ GOAL))
HOW (TUPLE EXAMINE MEMBER OF SPACE TO SEE IF IT MEETS CRITERIA)
WHY (TUPLE BECAUSE PUP MUST GET A MEMBER OF (@ SPACE)
WHICH SATISFIES (@ GOAL))
META:CODE (FOREACH ($ X)
IN
($ XSET)
DO
($ (TUPLE TEST (@ X)
(COMMENT FOR SATISFACTION OF GOAL CRITERIA))))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS ((COMMENT HER WE MUST NOTE THE TERMINATION CONDS.))
ALTERNATIVES (TUPLE GENERATE:AND:TEST COMPUTE)
IMPLICIT:ARGS (X XSET)
COMMENTS ((PROGN (DETERMINE:ARG:VALUE CHOICE)
(SETQ X (COLON:BACK (LIST POSSIBLE ARG1)))
(SETQ XSET (COLON:BACK (LIST SET:OF (PLURAL X)))))))
(PUTPROPS SERVE IDEN (((EQUAL LI (QUOTE (SERVE)))
(VECTOR SERVE)))
WHAT (TUPLE DO ANYTHING THE USER ASKS)
HOW (TUPLE GET A TASK FROM THE USER)
WHY (TUPLE FUNDAMENTAL DRIVE TO SERVE THE USER)
META:CODE (PROG (UNKNOWN:TASK)
(SETQ UNKNOWN:TASK NON:EXECUTABLE)
(SETQ BECAUSE (VECTOR THE CURRENT TASK (@ UNKNOWN:TASK)
IS NOT EXECUTABLE AND WE HAVE NOTHING ELSE TO DO AT THE PRESENT
TIME))
LABEL6
(COND ((NOT (MEMBER UNKNOWN:TASK EXECUTABLE:INFO:LIST))
(MAPC USER:INTERRUPT:DEMONS (QUOTE APPLY*))
(OBTAIN:USABLE:INFORMATION (QUOTE UNKNOWN:TASK))
(GO LABEL6)))
(SETQ ATTEMPTING:SOMETHING:LIST (CONS UNKNOWN:TASK ATTEMPTING:SOMETHING:LIST))
(SETQ ATTEMPTING:ANYTHING:LIST (CONS UNKNOWN:TASK ATTEMPTING:ANYTHING:LIST))
(SETQ BECAUSE (VECTOR WE FINALLY HAVE AN EXECUTABLE TO TASK TO DO, NAMELY
(@ UNKNOWN:TASK)))
(SETQ EXECUTABLE:INFO:LIST NIL)
(EVAL (CDR UNKNOWN:TASK)))
COMMENTS ((SETQ PUP:WANTS:LIST (CONS (VECTOR ANY TASK)
PUP:WANTS:LIST)))
PRE:REQUISITES ((VECTOR AWARE USER (VECTOR PUP WANTS ANY TASK)))
EXPLICIT:ARGS:CHECK T
MAIN:EFFECTS (((VECTOR ATTEMPTING SOMETHING)
(VECTOR SERVE))
((VECTOR ATTEMPTING ANYTHING)
(VECTOR SERVE)))
COMPLEXITY:VECTOR (.2 .4 .6 .8 .1)
SPECIALIZATIONS (WRITE:PROGRAM COUNSEL)
ALTERNATIVES (IGNORE REBEL)
BEING T
DEMONS (TUPLE FORGETFUL:USER:DEMON))
(PUTPROPS SIMPLE:COMPARE:FN BEING T
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE QUASI-COMPARISON WHICH ALWAYS RETURNS A CONSTANT VALUE)
HOW (TUPLE GET THE VALUE ONCE, AND ALWAYS RETURN IT)
WHY (TUPLE BECAUSE ORDERING ISNT VERY IMPORTANT HERE)
META:CODE (PROGN (ASK:USER:ABOUT VALUE))
COMPLEXITY:VECTOR (.4 .4 .4 .4 .1)
GENERALIZATIONS (TUPLE BETTER)
SPECIALIZATIONS (VECTOR (VECTOR DICHOTOMY
(QUOTE (VECTOR (VECTOR PUT EACH NEW ELEMENT ON AT THE
FRONT)
(VECTOR PUT EACH NEW ELEMENT ON AT THE
REAR)
(ERROR!)))
AFFECTS
(VECTOR THE SIMPLE:COMPARE:FN ALGORITHM)
RESULTS
(VECTOR (VECTOR PROGN
(COMMENT THIS ALLOWS MERGE TO BE THE SAME
AS CONS)
NIL)
(VECTOR PROGN
(COMMENT THIS ALLOWS MERGE TO BE THE SAME
AS NCONC1)
T))
SIMPLE:COMPARE:FN))
PREDICATE T)
(PUTPROPS SOME:PART:OF BEING T
EXPLICIT:ARGS (LIST:STRUC)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE THIS IS A DESTRUCTIVE FUNCTION; IT BREAKS A PIECE OFF OF (@ LIST:STRUC))
HOW (TUPLE USE SOME PRE:EXISTING TECHNIQUE TO GET THE SIMPLE LISP PROGRAM
(TUPLE MADE UP OF CARS AND CDRS)
WHICH DOES THE JOB. SUCH FACILITIES MIGHT BE PW1, PUP, DAVID SHAW'S PGM, OR EVEN
TRIAL AND ERROR.)
WHY (TUPLE ONLY PART OF (@ LIST:STRUC)
IS DESIRED AT THIS POINT)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .9)
GENERALIZATIONS (TUPLE FUNCTION SUBROUTINE PROGRAM SYSTEM)
SPECIALIZATIONS (VECTOR
(VECTOR
DICHOTOMY
(QUOTE (PROGN (VECTOR WE GET THE SOME:PART:OF FUNCTION (CADR CHOICE)
BY EXAMPLE I/O)
(VECTOR WE GET THE SOME:PART:OF FUNCTION (CADR CHOICE)
BY TRANSLATING AN EXPLICITLY USER-PROVIDED SENTENCE)
(ERROR!)))
RESULTS
(VECTOR
(QUOTE (LEARN:BY:EXAMPLE (VECTOR SOME:PART:OF (CADR CHOICE)
(DETERMINE:ARG:VALUE CHOICE)
(DETERMINE:ARG2:VALUE CHOICE))))
(QUOTE
(PROGN
(PUPRIN1
"
OK, NOW TYPE IN THE SENTENCE EQUIVALENT TO THE ACTION OF THE
SOME:PART:OF:FUNCTION IN QUESTION
USER: ")
(TRANSLATE (INVECTOR (PREAD))
T))))
AFFECTS
(VECTOR THE SOME:PART:OF ALGORITHM)
SOME:PART:OF))
IDEN (((MATCH (TUPLE SOME PART OF ANY1)
LI)
(VECTOR SOME:PART:OF (CADR (TRANSLATE (LIST VECTOR ANY1)
T))))
((MATCH (TUPLE SOME ELEMENTS OF ANY1)
LI)
(VECTOR SOME:PART:OF (CADR (TRANSLATE (LIST VECTOR ANY1)
T))))))
(PUTPROPS STUDY:TYPE BEING T
IDEN (((MATCH (QUOTE (STUDY:TYPE ANY1))
LI)
(VECTOR STUDY:TYPE (CADR LI))))
EXPLICIT:ARGS (B:CALL)
EXPLICIT:ARGS:CHECK (GETP (CADR B:CALL)
BEING)
WHAT (TUPLE INVESTIGATE THE VARIOUS SPECIALIZATIONS OF (@ B:CALL))
HOW (TUPLE TRANSFER THE SPECIALIZATIONS (GETP (CADR B:CALL)
SPECIALIZATIONS)
OF
(@ B:CALL)
ONTO THE LIST OF DECISIONS WHICH MUST BE ATTENDED TO)
WHY (TUPLE BECAUSE THE MORE SPECIFIC OUR KNOWLEDGE OF WHAT IS WANTED, THE MORE EASILY AND
COMPLETELY WE MAY SATISFY THAT REQUEST)
MAIN:EFFECTS (((VECTOR TYPE OF (VECTOR ANY1 HAS BEEN STUDIED))
(VECTOR STUDY:TYPE (@ ANY1)))
((VECTOR PUP STUDIED (VECTOR TYPE OF ANY1))
(VECTOR STUDY:TYPE (@ ANY1))))
META:CODE (PROGN (MAPC (CDR (GETP (CADR B:CALL)
SPECIALIZATIONS))
(FUNCTION (LAMBDA (A)
(SETQ UNDEFERRED:DECISION:LIST
(NCONC1 UNDEFERRED:DECISION:LIST
(COND ((ATOM A)
A)
((ATOM (CAR A))
(EVAL A))
((APPLY* (EVAL (CAR A))
B:CALL))))))))
(SETQ PUP:STUDIED:LIST (CONS (VECTOR TYPE OF (@ B:CALL))
PUP:STUDIED:LIST))
(SETQ TYPE:OF:LIST (CONS (VECTOR (@ B:CALL)
HAS BEEN STUDIED)
TYPE:OF:LIST)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS TAKE:HOLD:OF BEING T
EXPLICIT:ARGS (ENTITY)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE TAKE THE ENTITY (@ ENTITY)
IN A TRIVIAL WAY; EITHER BY ACCESSING IT OR BY READING IT IN)
HOW (TUPLE LOOK AROUND A LITTLE; IF IT ISNT FOUND TRIVIALLY, THEN ASK THE USER TO GIVE
(@ ENTITY)
TO US)
WHY (TUPLE PUP WANTS (@ ENTITY)
,AND WE DON'T HAVE TO DO ANY COMPUTING TO GET IT)
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
SPECIALIZATIONS (VECTOR (VECTOR DICHOTOMY (QUOTE (AND (FLOW:PRECEDED (VECTOR SETQ
(@ ARG1)
ANY1))
(PUPRINT (TUPLE THE ASSIGNMENT WHICH SET
(@ ARG1)
,NAMELY
(@ FLOW:ASSIGNMENT)
,WAS DONE EARLIER;
SHOULD A NEW VALUE OF
(@ ARG1)
BE PREAD IN AT THIS
POINT IN THE PROGRAM
FLOW? USER...))
(MEMBER (PREAD)
(VECTOR NIL NO N))
T))
AFFECTS
(VECTOR THE TAKE:HOLD:OF ALGORITHM)
RESULTS
(VECTOR (COMMENT DO NOTHING SINCE WE ALREADY HAVE WHAT WE WANT)
(QUOTE (APPEND
(TUPLE PROGN (VECTOR SET ARG1 (TUPLE PREAD)))
(MAPCAR (CDR (GETP (EVAL ARG1)
META:CODE))
(FUNCTION
(LAMBDA
(EPART TCODE)
(SETQQ NEWNAME NEWNAME)
(PUPRINT (TUPLE PUP IS ABOUT TO
ENCODE AN
ASSIGNMENT:
(@ EPART)
WILL BE SET TO
SOME PART OF ARG1
WHICH IS GOING TO
BE INSTANTIATED
DURING THE
RUNNING OF THE
PROGRAM AS
(EVAL ARG1)
.PUP WANTS A NAME
FOR THIS 'SOME
PART OF'
FUNCTION.))
(SETQ ARG:LIST
(CDR (SASSOC (CADR CHOICE)
(OUTVECTOR
FN:CALL:LIST)
)))
(SETQ TCODE
(GETCODE
(TUPLE SETQ (COLON:BACK
EPART)
(TUPLE
SOME:PART:OF
ARG1))
(CADR CHOICE)
-1))
(SETQ NEW:THING:LIST
(CONS (CADR TCODE)
NEW:THING:LIST))
(SETQ TYPE:OF:LIST
(CONS (VECTOR (CADR TCODE)
TYPE OF
(CONS VECTOR
EPART)
IS USED IN
THE
ASSIGNMENT
STATEMENT
(@ TCODE)
IN
(CADR CHOICE))
TYPE:OF:LIST))
TCODE)))
(PROGN (SETQ NEW:THING:LIST
(CONS (EVAL ARG1)
NEW:THING:LIST))
(LIST T)))))
TAKE:HOLD:OF))
NLAMBDA T)
(PUTPROPS TEST BEING T
EXPLICIT:ARGS (ENTITY DESCRIPTION:OF:CONDITION)
EXPLICIT:ARGS:CHECK T
WHAT (TUPLE TEST TO SEE IF THE ENTITY (@ ENTITY)
MEETS THE DESIRED CONDITIONS (@ DESCRIPTION:OF:CONDITION))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1)
PREDICATE T
SPECIALIZATIONS (VECTOR (VECTOR DICHOTOMY
(PROGN (VECTOR THE TESTING MAY HAVE THE CHARACTER OF COMPARING THE
OBJECT (VECTOR THAT IS, ARG1, ALSO KNOWN AS
(TUPLE TUPLE CADDR ENT1))
WITH SOME DISTINGUISHED OBJECT)
(VECTOR TESTING MAY HAVE THE CHARACTER OF LETTING THE OBJECT
(VECTOR WHICH IS ARG1)
COMPETE WITH ITS FELLOW OBJECTS FOR SUPREMACY)
(COND ((INFER:INSIDE (CADR CHOICE)
FOREACH)
T)
((INFER:INSIDE (CADR CHOICE)
EXTREMUM)
NIL)
(T (ERROR))))
AFFECTS
(VECTOR THE TEST ALGORITHM)
RESULTS
(VECTOR (VECTOR COMPARE ARG1 (MOST:GENERAL NEW:THING:LIST))
(VECTOR REPEATEDLY (VECTOR COMPARE ARG1 CURRENT:BEST:ARG1)
(VECTOR REVISE CURRENT:BEST:ARG1)))
COMMENT
(COMMENT THE "DISTINGUISHED OBJECT" IS ASSUMED TO BE A NEWLY-ACQUIRED
ONE, PROBABLY JUST PREAD IN. IT WILL BE ONE OF THESE:
(@ NEW:THING:LIST)
;PROBABLY THIS ONE: (MOST:GENERAL NEW:THING:LIST)
%. "COMPETING" MEANS THAT EACH ARG1 IS COMPARED WITH THE
PARTICULAR OLD ARG1-VALUE WHICH HAS
(VECTOR SO FAR, AT LEAST)
RECEIVED THE HIGHEST RATING; I.E., DEFEATED ALL CHALLENGERS.
THUS, THE ARG1-VALUE RETAINED AT THE END SHOULD BE THE BEST
ONE. THIS PRESUPPOSES THAT THE COMPARISON FUNCTION IS
TRANSITIVE.)
TEST)
(VECTOR ALTERNATIVES (VECTOR NOMINAL:RESULT ORDINAL:RESULT RATIO:RESULT)
AFFECTS
(VECTOR WHETHER NO OTHER, ALL OTHER, OR ALL OTHER OBJECTS MUST BE
EXAMINED)
WHEN
(VECTOR BEFORE DECIDING FIRMLY HOW TO TEST (TUPLE TUPLE CADDR ENT1))
TEST)))
(PUTPROPS TRANSLATE IDEN (((AND (EQUAL (CAR LI)
TRANSLATE T)
(EQUAL (LENGTH LI)
2))
(VECTOR TRANSLATE (CADR LI))))
BEING T
EXPLICIT:ARGS (NEW:INFO FORCE:TRANSLATE)
WHAT (TUPLE TRANSLATE A PIECE OF UNTRANSLATED NEW INFORMATION)
HOW (TUPLE TRANSFORM (@ NEW:INFO)
INTO MORE EXECUTABLE FORM)
WHY (TUPLE EW INFORMATION (@ NEW:INFO)
IS DECLARATIVE AND MUST BE MADE PROCEDURAL BEFORE IT MAY BE USED BY THE SYSTEM)
WHEN ((T (COND (USABLE:INFO:LIST -60)
(T 50))
(QUOTE (BECAUSE THE ABSENCE OF USABLE INFORMATION ABDUCTIVELY CALLS FOR ITS PRODUCTION;
ITS PRESENCE DEMANDS ITS ASSIMILATION)))
((MEMBER (EVAL NEW:INFO)
TRANSLATED:INFO:LIST)
-111
(VECTOR BECAUSE WE HAVE ALREADY TRANSLATED IT IMPLIES WE SHOULDNT NOW)))
META:CODE (PROG (LI TEMPTR)
(SETQ LI (CDR EV:NEW:INFO))
(SETQ NEW:INFO:LIST (PULLOUT EV:NEW:INFO NEW:INFO:LIST))
(MAPC IDEN:TABLE (FUNCTION (LAMBDA (II)
(COND ((EVAL (CAR II))
(COND ((SETQ TEMPTR
(EVAL (CADR II)))
(SETQ TRANSLATED:PAIR:LIST
(CONS (LIST EV:NEW:INFO
TEMPTR)
TRANSLATED:PAIR:LIST)
)
(SETQ TRANSLATED:INFO:LIST
(CONS EV:NEW:INFO
TRANSLATED:INFO:LIST))
(COND ((NOT FORCE:TRANSLATE)
(SETQ
EXECUTABLE:INFO:LIST
(CONS TEMPTR
EXECUTABLE:INFO:LIST)))))
)
(RETURN TEMPTR))))))
(PUPRIN1 "SORRY, I T TRANSLATE
PLEA
PLEA")
(PUPRIN1 "
PLEASE RETYPE THE FOLLOWING, REPHRASING IT SO I CAN COMPREHEND IT:
")
(PUPRIN1 EV:NEW:INFO)
(RETURN (TRANSLATE (INVECTOR (PREAD))
T)))
EXPLICIT:ARGS:CHECK (OR (MEMBER (EVAL NEW:INFO)
NEW:INFO:LIST)
(NULL (EVAL NEW:INFO))
FORCE:TRANSLATE
(COND (NEW:INFO:LIST (SETQQ NEW:INFO UNKNOWN:TASK)
(SET NEW:INFO (CAR NEW:INFO:LIST)))))
DEMONS (TUPLE IDIOM:DEMON)
MAIN:EFFECTS (((VECTOR USABLE INFO (VECTOR NEW INFO ANY1))
(VECTOR TRANSLATE (@ ANY1)))
((VECTOR TRANSLATED INFO ANY1)
(VECTOR TRANSLATE (@ ANY1))))
MINOR:EFFECTS ((VECTOR NEW INFO))
AFFECTS (QUOTE ((LOOKUP CALLED)
(PARSE CALLED)))
COMPLEXITY:VECTOR (.3 .5 .5 .5 .1)
COMMENTS ((SETQ EV:NEW:INFO (EVAL NEW:INFO)))
IMPLICIT:ARGS (EV:NEW:INFO PART1 PART2))
(PUTPROPS USE:INFORMATION BEING T
IMPLICIT:ARGS (ACTION)
EXPLICIT:ARGS (PROGRAM)
EXPLICIT:ARGS:CHECK EXECUTABLE:INFO:LIST
WHAT (TUPLE USE SOME AVAILABLE INFORMATION)
HOW (TUPLE PICK ONE OF (@ EXECUTABLE:INFO:LIST)
AND DO IT)
WHY (TUPLE IF WE DON'T DO WHAT WE CAN AS SOON AS POSSIBLE, WE MIGHT NEEDLESSLY BOTHER THE
USER, OUR SLOWEST CHANNNEL)
WHEN ((EXECUTABLE:INFO:LIST 120
(TUPLE BECAUSE WE COULD BE GOING IN CIRCLES IF WE DON'T DO WHAT
WE CAN AS SOON AS POSSIBLE)))
META:CODE (PROGN (SETQ ACTION (COND ((GETP (CAR (OUTVECTOR (CAR EXECUTABLE:INFO:LIST)))
NON:EVAL:ARGS)
(COND ((EQUAL (CAAR EXECUTABLE:INFO:LIST)
VECTOR)
(CDAR EXECUTABLE:INFO:LIST))
(T (CAR EXECUTABLE:INFO:LIST))))
(T (OUTVECTOR (CAR EXECUTABLE:INFO:LIST)))))
(SETQ EXECUTABLE:INFO:LIST (CDR EXECUTABLE:INFO:LIST))
(COND ((EVAL ACTION))
(T (NCONC1 EXECUTABLE:INFO:LIST ACTION)
NIL)))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS UTILIZE BEING T
IDEN (((AND (EQUAL (CAR LI)
UTILIZE)
(EQUAL (LENGTH LI)
4))
(VECTOR UTILIZE (TRANSLATE (CADR LI))
(CADDR LI)
(CADDDR LI))))
IMPLICIT:ARGS (KNOW:LIST DEC)
EXPLICIT:ARGS (KNOW:NAME APPLIED:SO:AS:TO:KEEP INVARIANT)
EXPLICIT:ARGS:CHECK (AND (EQUAL (CAR INVARIANT)
VECTOR)
(MEMBER (CADR INVARIANT)
(QUOTE (RELEVANT IRRELEVANT)))
(ATOM KNOW:NAME)
(OR (NULL (EVAL KNOW:NAME))
(LISTP (EVAL KNOW:NAME))))
WHAT (TUPLE USE THE LIST (@ KNOW:LIST)
OF INFORMATION TO DECIDE THE TURNING POINT OF THE TRUTH OF THE PREDICATE (@ INVARIANT))
HOW (TUPLE SEARCH THROUGH (@ KNOW:LIST)
FOR APPLICABLE RULES)
WHY (TUPLE SO PUP KNOWS WHEN (@ INVARIANT)
CHANGES TRUTH VALUE)
META:CODE (PROG (AF HOLD:ANY2)
(COND ((MATCH (VECTOR ANY2 (VECTOR PUP REINVESTIGATE FRAG1))
INVARIANT)
(SETQ HOLD:ANY2 ANY2)
(SETQ DEC (CONS VECTOR FRAG1))
(COND ((AND (SETQ AF (CADR (MEMBER WHEN DEC)))
(MAPC (EVAL (COLON:BACK (CONS WHEN:ALL (CDR (COLON:BREAK
KNOW:NAME)))))
(FUNCTION (LAMBDA (K)
(COND ((MATCH (CAR K)
AF)
(RETURN (EVAL (CADR K))))))))))
((AND (SETQ AF (CADR (MEMBER AFFECTS DEC)))
(MAPC (EVAL (COLON:BACK (CONS AFFECTS:ALL (CDR (COLON:BREAK
KNOW:NAME)))))
(FUNCTION (LAMBDA (K)
(COND ((MATCH (CAR K)
AF)
(RETURN (EVAL (CADR K))))))))))
((MAPC KNOW:LIST (FUNCTION (LAMBDA (K)
(COND ((SETQ AF (EVAL K))
(RETURN (VECTOR
(OPPOSITE
HOLD:ANY2)
(@ AF)))))))))
(T (RETURN NIL))))
(T (RETURN NIL))))
COMMENTS ((OR (SETQ KNOW:LIST (EVAL KNOW:NAME))
T))
COMPLEXITY:VECTOR (.5 .5 .5 .5 .1))
(PUTPROPS WHEN:NEXT BEING T
IDEN (((MATCH (QUOTE (WHEN:NEXT (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADR LI)))
((MATCH (QUOTE (THE NEXT TIME (VECTOR ANY1 ANY2 ANY3)))
LI)
(VECTOR WHEN:NEXT (CADDDR LI))))
IMPLICIT:ARGS (UTILIZATION UTIL2 AWARE:LIST)
EXPLICIT:ARGS (ACT)
EXPLICIT:ARGS:CHECK (AND (MEMBER (CADR ACT)
(QUOTE (USER PUP)))
(EQUAL (LENGTH ACT)
4))
WHAT (TUPLE FIND THE NEXT SITUATION IN WHICH (CADR ACT)
MUST PERFORM THE OPERATION (CADDR ACT)
ON
(CADDDR ACT))
HOW (TUPLE EXPLORE THE EFFECTS OF (CADDR ACT)
ING
(CADDDR ACT))
WHY (TUPLE (CADR ACT)
CAN THEN FORGET (CADDDR ACT)
UNTIL THE NEXT SITUATION WE FIND HERE)
MAIN:EFFECTS (((VECTOR AWARE ANY1 (DELAYABLE ANY2))
(VECTOR WHEN:NEXT (VECTOR (@ ANY1)
(CADR ANY2)
(CADDR ANY2)))))
META:CODE (PROGN (SETQ RELEVANT:KNOWLEDGE (COLON:BACK (COPY (TUPLE (CADR (CADDDR ACT))
(CADR BEING:STACK)
KNOWLEDGE))))
(SETQ UTILIZATION (VECTOR DELAYABLE (@ ACT)
UNTIL
(SETQ UTIL2 (UTILIZE
RELEVANT:KNOWLEDGE APPLIED:SO:AS:TO:KEEP
(VECTOR IRRELEVANT (APPEND
(VECTOR (CADR ACT)
(CADDR ACT))
(CDDAR (CDDDR ACT))))))))
(SETQ AWARE:LIST (COLON:BACK (COPY (LIST (QUOTE AWARE)
(CADR ACT)
(QUOTE LIST)))))
(SET AWARE:LIST (CONS UTILIZATION (EVAL AWARE:LIST)))
UTIL2)
COMPLEXITY:VECTOR (.6 .7 .5 .5 .1))
(PUTPROPS WRITE:PROGRAM IDEN (((AND (EQUAL (CAR LI)
WRITE:PROGRAM)
(EQUAL (LENGTH LI)
2))
(VECTOR WRITE:PROGRAM (TRANSLATE (CADR LI)
T)))
((MATCH (QUOTE (WRITE A PROGRAM WHICH DOES FRAG1))
LI)
(VECTOR WRITE:PROGRAM (TRANSLATE (INVECTOR FRAG1)
T))))
BEING T
IMPLICIT:ARGS (TASK:TYPE TASK:NAME FARGS)
EXPLICIT:ARGS (TASK)
WHAT (TUPLE WRITE A PROGRAM WHICH DOES (@ TASK))
HOW (TUPLE CREATE SPECIALIZED LISP CODE WHICH WILL DO (@ TASK))
WHY (TUPLE FUNDAMENTAL DRIVE TO OBEY USER; ALSO, IT IS NECESSARY THAT CODE BE WRITTEN TO DO
(@ TASK)
IN ORDER THAT THE TASK (@ TASK)
MIGHT BE COMPLETED; ALSO, EXAMINE SPEC:WHY)
WHEN ((T (COND ((MEMBER TASK ABLE:PUP:LIST)
-75)
(T 40))
(TUPLE BECAUSE A PRE:EXISTING ABILITY TO DO (@ TASK)
IMPLIES THAT WRITING A NEW PROGRAM TO ACCOMPLISH IT IS SUPERFLUOUS AND,
CONVERSELY, THE INABILITY TO DO (@ TASK)
ABDUCTIVELY ENCOURAGES US THAT WE ARE ON THE RIGHT TRACK))
((MEMBER TASK WRITTEN:PROGRAMS:LIST)
-80
(QUOTE (BECAUSE WE ARE NOT AFTER MUCH EFFICIENCY, AND IF A PROGRAM ALREADY EXISTS,
THEN WE SHOULD USE IT)))
((MEMBER (TUPLE PUP IS ABOUT TO WRITE A PROGRAM TO DO (@ TASK))
AWARE:USER:LIST)
70
(QUOTE (BECAUSE WE GO BY THE OLD ENGLISH LEGAL RULE, THAT SILENCE SIGNIFIES APPROVAL)))
(T (COND (NEW:INFO:LIST -120)
(T 40))
(QUOTE (BECAUSE WE SHOULD USE UP THE NEW INFORMATION BEFORE WRITING PROGRAMS ALSO:
BECAUSE IF NO NEW INFO IS PRESENT, THEN WE NEEDN'T FEEL GUILTY ABOUT
STARTING TO WRITE A PROGRAM))))
META:CODE (PROG (DONE PGM)
(SETQ PGM (VECTOR))
(SETQ UNDEFINED:SECTION:LIST (CONS (VECTOR (@ TASK:NAME)
TYPE OF (@ TASK))
UNDEFINED:SECTION:LIST))
LABEL4
(ECONOMY:DEMON)
(COND ((AND (GETP TASK:NAME BEING)
(NULL CODING:WARNING:LIST)
(NULL EXECUTABLE:INFO:LIST)
(NULL NEW:INFO:LIST)
(NULL UNDEFINED:SECTION:LIST))
(COND (DEFERRED:DECISION:LIST (SETQ DOING:PUP:LIST
(CONS (VECTOR DETAIL OF OUTPUTING)
DOING:PUP:LIST))
(SETQ CHOICE NIL)
(REINVESTIGATION:DEMON)))
(SETQ WRITTEN:PROGRAMS:LIST (CONS TASK WRITTEN:PROGRAMS:LIST))
(SETQ ABLE:PUP:LIST (CONS TASK ABLE:PUP:LIST))
(SETQ ABLE:USER:LIST (CONS TASK ABLE:USER:LIST))
(RETURN T))
((NOT (MEMBER NIL (MAPCAR (APPEND USER:INTERRUPT:DEMONS CURRENT:DEMONS)
(QUOTE APPLY*))))
(CHOOSE:FROM (QUOTE ((OBTAIN:USABLE:INFORMATION (QUOTE PGM))
(USE:INFORMATION (QUOTE PGM))
(FILL:IN:UNDEFINED:SECTION (QUOTE PGM))
(CLARIFY:IMPROBABLE:SITUATION (QUOTE PGM))
(ADAPT:PRECONCEIVED:FUNCTION (QUOTE PGM))
(FIX:INCORRECT:PIECE (QUOTE PGM)))))
(GO LABEL4))
(T (RETURN NIL))))
PRE:REQUISITES ((VECTOR AWARE USER (VECTOR PUP IS ABOUT TO WRITE A PROGRAM TO DO
(@ TASK)))
(VECTOR NAMED EXPRESSION (@ TASK)
(VECTOR TASK:NAME))
(VECTOR AWARE USER (VECTOR THE NAME OF THE PROGRAM TO DO (@ TASK)
IS
(@ TASK:NAME)))
(VECTOR TYPE OF (VECTOR (@ TASK)
HAS BEEN STUDIED)))
POST:REQUISITES ((VECTOR AWARE USER (VECTOR THE PROGRAM (@ TASK:NAME)
TO DO (@ TASK)
IS COMPLETE)))
EXPLICIT:ARGS:CHECK T
DEMONS (TUPLE PROGRAM:WRITING:DEMONS DEFERRAL:DEMON REINVESTIGATION:DEMON)
MAIN:EFFECTS (((VECTOR ABLE PUP ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR WRITTEN PROGRAMS ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1)))
((VECTOR ABLE USER ANY1)
(VECTOR WRITE:PROGRAM (@ ANY1))))
AFFECTS (QUOTE ((OBTAIN:USABLE:INFORMATION POSSIBLE:CALLED)
(USE:INFORMATION POSSIBLE:CALLED)
(FILL:IN:UNDEFINED:SECTION POSSIBLE:CALLED)
(CLARIFY:IMPROBABLE:SITUATION POSSIBLE:CALLED)
(ADAPT:PRECONCEIVED:FUNCTION POSSIBLE:CALLED)))
COMPLEXITY:VECTOR ((PLUS .3 (TIMES .6 (DIMENSION1 TASK:TYPE)))
.9 .7 .5 .1))
(MAPC (APPEND PUP5FNS SET:OF:BEINGS SET:OF:BEING:PARTS ADJECTIVES)
(FUNCTION (LAMBDA (V)
(SET V V))))
(SETQ #RPARS NIL)
(DWIM)
(CHANGESLICE 6)
(SETQ GLOBALVARS HOLD:GLOBALVARS)
(SET:UP:IDEN:TABLE)
(SET:UP:EFFECTS:TABLE)
(WIDEPAPER T)
(MAPC SET:OF:BEINGS SEMI:COMPILE)
(PRIN1 " MINI PUP FILE: USE FAD OR AD OR MAKEFILE FOR NEW VERSION ")
STOP